int area_area(struct Map_info *In, int *field, struct Map_info *Tmp,
struct Map_info *Out, struct field_info *Fi,
dbDriver * driver, int operator, int *ofield,
ATTRIBUTES * attr, struct ilist *BList, double snap)
{
int ret, input, line, nlines, area, nareas;
int in_area, in_centr, out_cat;
struct line_pnts *Points;
struct line_cats *Cats;
CENTR *Centr;
char buf[1000];
dbString stmt;
int nmodif;
int verbose;
verbose = G_verbose();
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* optional snap */
if (snap > 0) {
int i, j, snapped_lines = 0;
struct bound_box box;
struct boxlist *boxlist = Vect_new_boxlist(0);
struct ilist *reflist = Vect_new_list();
G_message(_("Snapping boundaries with %g ..."), snap);
/* snap boundaries in B to boundaries in A,
* not modifying boundaries in A */
if (BList->n_values > 1)
qsort(BList->value, BList->n_values, sizeof(int), cmp_int);
snapped_lines = 0;
nlines = BList->n_values;
for (i = 0; i < nlines; i++) {
line = BList->value[i];
Vect_read_line(Tmp, Points, Cats, line);
/* select lines by box */
Vect_get_line_box(Tmp, line, &box);
box.E += snap;
box.W -= snap;
box.N += snap;
box.S -= snap;
box.T = 0.0;
box.B = 0.0;
Vect_select_lines_by_box(Tmp, &box, GV_BOUNDARY, boxlist);
if (boxlist->n_values > 0) {
Vect_reset_list(reflist);
for (j = 0; j < boxlist->n_values; j++) {
int aline = boxlist->id[j];
if (!bsearch(&aline, BList->value, BList->n_values,
sizeof(int), cmp_int)) {
G_ilist_add(reflist, aline);
}
}
/* snap bline to alines */
if (Vect_snap_line(Tmp, reflist, Points, snap, 0, NULL, NULL)) {
/* rewrite bline*/
Vect_delete_line(Tmp, line);
ret = Vect_write_line(Tmp, GV_BOUNDARY, Points, Cats);
G_ilist_add(BList, ret);
snapped_lines++;
G_debug(3, "line %d snapped", line);
}
}
}
Vect_destroy_boxlist(boxlist);
Vect_destroy_list(reflist);
G_verbose_message(n_("%d boundary snapped",
"%d boundaries snapped",
snapped_lines), snapped_lines);
}
/* same procedure like for v.in.ogr:
* Vect_clean_small_angles_at_nodes() can change the geometry so that new intersections
* are created. We must call Vect_break_lines(), Vect_remove_duplicates()
* and Vect_clean_small_angles_at_nodes() until no more small dangles are found */
do {
G_message(_("Breaking lines..."));
Vect_break_lines_list(Tmp, NULL, BList, GV_BOUNDARY, NULL);
/* Probably not necessary for LINE x AREA */
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(Tmp, GV_BOUNDARY, NULL);
G_message(_("Cleaning boundaries at nodes..."));
nmodif =
Vect_clean_small_angles_at_nodes(Tmp, GV_BOUNDARY, NULL);
} while (nmodif > 0);
/* ?: May be result of Vect_break_lines() + Vect_remove_duplicates() any dangle or bridge?
* In that case, calls to Vect_remove_dangles() and Vect_remove_bridges() would be also necessary */
G_set_verbose(0);
/* should be fast, be silent */
Vect_build_partial(Tmp, GV_BUILD_AREAS);
G_set_verbose(verbose);
nlines = Vect_get_num_lines(Tmp);
ret = 0;
for (line = 1; line <= nlines; line++) {
if (!Vect_line_alive(Tmp, line))
continue;
if (Vect_get_line_type(Tmp, line) == GV_BOUNDARY) {
int left, rite;
Vect_get_line_areas(Tmp, line, &left, &rite);
if (left == 0 || rite == 0) {
/* invalid boundary */
ret = 1;
break;
}
}
}
if (ret) {
Vect_remove_dangles(Tmp, GV_BOUNDARY, -1, NULL);
Vect_remove_bridges(Tmp, NULL, NULL, NULL);
}
G_set_verbose(0);
Vect_build_partial(Tmp, GV_BUILD_NONE);
Vect_build_partial(Tmp, GV_BUILD_BASE);
G_set_verbose(verbose);
G_message(_("Merging lines..."));
Vect_merge_lines(Tmp, GV_BOUNDARY, NULL, NULL);
/* Attach islands */
G_message(_("Attaching islands..."));
/* can take some time, show messages */
Vect_build_partial(Tmp, GV_BUILD_ATTACH_ISLES);
/* Calculate new centroids for all areas */
nareas = Vect_get_num_areas(Tmp);
Centr = (CENTR *) G_malloc((nareas + 1) * sizeof(CENTR)); /* index from 1 ! */
for (area = 1; area <= nareas; area++) {
ret =
Vect_get_point_in_area(Tmp, area, &(Centr[area].x),
&(Centr[area].y));
if (ret < 0) {
G_warning(_("Cannot calculate area centroid"));
Centr[area].valid = 0;
}
else {
Centr[area].valid = 1;
}
}
/* Query input maps */
for (input = 0; input < 2; input++) {
G_message(_("Querying vector map <%s>..."),
Vect_get_full_name(&(In[input])));
for (area = 1; area <= nareas; area++) {
Centr[area].cat[input] = Vect_new_cats_struct();
G_percent(area, nareas, 1);
in_area =
Vect_find_area(&(In[input]), Centr[area].x, Centr[area].y);
if (in_area > 0) {
in_centr = Vect_get_area_centroid(&(In[input]), in_area);
if (in_centr > 0) {
int i;
Vect_read_line(&(In[input]), NULL, Cats, in_centr);
/* Add all cats with original field number */
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == field[input]) {
ATTR *at;
Vect_cat_set(Centr[area].cat[input], ofield[input + 1],
Cats->cat[i]);
/* Mark as used */
at = find_attr(&(attr[input]), Cats->cat[i]);
if (!at)
G_fatal_error(_("Attribute not found"));
at->used = 1;
}
}
}
}
}
}
G_message(_("Writing centroids..."));
db_init_string(&stmt);
out_cat = 1;
for (area = 1; area <= nareas; area++) {
int i;
G_percent(area, nareas, 1);
/* check the condition */
switch (operator) {
case OP_AND:
if (!
(Centr[area].cat[0]->n_cats > 0 &&
Centr[area].cat[1]->n_cats > 0))
continue;
break;
case OP_OR:
if (!
(Centr[area].cat[0]->n_cats > 0 ||
Centr[area].cat[1]->n_cats > 0))
continue;
break;
case OP_NOT:
if (!
(Centr[area].cat[0]->n_cats > 0 &&
!(Centr[area].cat[1]->n_cats > 0)))
continue;
break;
case OP_XOR:
if ((Centr[area].cat[0]->n_cats > 0 &&
Centr[area].cat[1]->n_cats > 0) ||
(!(Centr[area].cat[0]->n_cats > 0) &&
!(Centr[area].cat[1]->n_cats > 0)))
continue;
break;
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, Centr[area].x, Centr[area].y, 0.0);
if (ofield[0] > 0) {
/* Add new cats for all combinations of input cats (-1 in cycle for null) */
for (i = -1; i < Centr[area].cat[0]->n_cats; i++) {
int j;
if (i == -1 && Centr[area].cat[0]->n_cats > 0)
continue; /* no need to make null */
for (j = -1; j < Centr[area].cat[1]->n_cats; j++) {
if (j == -1 && Centr[area].cat[1]->n_cats > 0)
continue; /* no need to make null */
if (ofield[0] > 0)
Vect_cat_set(Cats, ofield[0], out_cat);
/* attributes */
if (driver) {
ATTR *at;
sprintf(buf, "insert into %s values ( %d", Fi->table,
out_cat);
db_set_string(&stmt, buf);
/* cata */
if (i >= 0) {
if (attr[0].columns) {
at = find_attr(&(attr[0]),
Centr[area].cat[0]->cat[i]);
if (!at)
G_fatal_error(_("Attribute not found"));
if (at->values)
db_append_string(&stmt, at->values);
else
db_append_string(&stmt, attr[0].null_values);
}
else {
sprintf(buf, ", %d", Centr[area].cat[0]->cat[i]);
db_append_string(&stmt, buf);
}
}
else {
if (attr[0].columns) {
db_append_string(&stmt, attr[0].null_values);
}
else {
sprintf(buf, ", null");
db_append_string(&stmt, buf);
}
}
/* catb */
if (j >= 0) {
if (attr[1].columns) {
at = find_attr(&(attr[1]),
Centr[area].cat[1]->cat[j]);
if (!at)
G_fatal_error(_("Attribute not found"));
if (at->values)
db_append_string(&stmt, at->values);
else
db_append_string(&stmt, attr[1].null_values);
}
else {
sprintf(buf, ", %d", Centr[area].cat[1]->cat[j]);
db_append_string(&stmt, buf);
}
}
else {
if (attr[1].columns) {
db_append_string(&stmt, attr[1].null_values);
}
else {
sprintf(buf, ", null");
db_append_string(&stmt, buf);
}
}
db_append_string(&stmt, " )");
G_debug(3, "%s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_warning(_("Unable to insert new record: '%s'"),
db_get_string(&stmt));
}
out_cat++;
}
}
}
/* Add all cats from input vectors */
if (ofield[1] > 0 && field[0] > 0) {
for (i = 0; i < Centr[area].cat[0]->n_cats; i++) {
if (Centr[area].cat[0]->field[i] == field[0])
Vect_cat_set(Cats, ofield[1], Centr[area].cat[0]->cat[i]);
}
}
if (ofield[2] > 0 && field[1] > 0 && ofield[1] != ofield[2]) {
for (i = 0; i < Centr[area].cat[1]->n_cats; i++) {
if (Centr[area].cat[1]->field[i] == field[1])
Vect_cat_set(Cats, ofield[2], Centr[area].cat[1]->cat[i]);
}
}
Vect_write_line(Tmp, GV_CENTROID, Points, Cats);
Vect_write_line(Out, GV_CENTROID, Points, Cats);
}
G_set_verbose(0);
/* should be fast, be silent */
Vect_build_partial(Tmp, GV_BUILD_CENTROIDS);
G_set_verbose(verbose);
/* Copy valid boundaries to final output */
nlines = Vect_get_num_lines(Tmp);
for (line = 1; line <= nlines; line++) {
int i, ltype, side[2], centr[2];
G_percent(line, nlines, 1); /* must be before any continue */
if (!Vect_line_alive(Tmp, line))
continue;
ltype = Vect_read_line(Tmp, Points, Cats, line);
if (!(ltype & GV_BOUNDARY))
continue;
Vect_get_line_areas(Tmp, line, &side[0], &side[1]);
for (i = 0; i < 2; i++) {
if (side[i] == 0) { /* This should not happen ! */
centr[i] = 0;
continue;
}
if (side[i] > 0) {
area = side[i];
}
else { /* island */
area = Vect_get_isle_area(Tmp, abs(side[i]));
}
if (area > 0)
centr[i] = Vect_get_area_centroid(Tmp, area);
else
centr[i] = 0;
}
if (centr[0] || centr[1])
Vect_write_line(Out, GV_BOUNDARY, Points, Cats);
}
return 0;
}
/*!
\brief Extensive tests for correct topology
- lines or boundaries of zero length
- intersecting boundaries, ie. overlapping areas
- areas without centroids that are not isles
\param Map vector map
\param[out] Err vector map where errors will be written or NULL
\return 1 on success
\return 0 on error
*/
int Vect_topo_check(struct Map_info *Map, struct Map_info *Err)
{
int line, nlines;
int nerrors, n_zero_lines, n_zero_boundaries;
struct line_pnts *Points;
struct line_cats *Cats;
/* rebuild topology if needed */
if (Vect_get_built(Map) != GV_BUILD_ALL) {
Vect_build_partial(Map, GV_BUILD_NONE);
Vect_build(Map);
}
G_message(_("Checking for topological errors..."));
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* lines or boundaries of zero length */
n_zero_lines = n_zero_boundaries = 0;
nlines = Vect_get_num_lines(Map);
for (line = 1; line <= nlines; line++) {
int type;
if (!Vect_line_alive(Map, line))
continue;
type = Vect_get_line_type(Map, line);
if (type & GV_LINES) {
double len;
Vect_read_line(Map, Points, Cats, line);
len = Vect_line_length(Points);
if (len == 0) {
if (type & GV_LINE)
n_zero_lines++;
else if (type & GV_BOUNDARY)
n_zero_boundaries++;
if (Err)
Vect_write_line(Err, type, Points, Cats);
}
}
}
if (n_zero_lines)
G_warning(_("Number of lines of length zero: %d"), n_zero_lines);
if (n_zero_boundaries)
G_warning(_("Number of boundaries of length zero: %d"), n_zero_boundaries);
/* remaining checks are for areas only */
if (Vect_get_num_primitives(Map, GV_BOUNDARY) == 0)
return 1;
/* intersecting boundaries -> overlapping areas */
nerrors = Vect_check_line_breaks(Map, GV_BOUNDARY, Err);
if (nerrors)
G_warning(_("Number of boundary intersections: %d"), nerrors);
/* areas without centroids that are not isles
* only makes sense if all boundaries are correct */
nerrors = 0;
for (line = 1; line <= nlines; line++) {
int type;
if (!Vect_line_alive(Map, line))
continue;
type = Vect_get_line_type(Map, line);
if (type == GV_BOUNDARY) {
struct P_topo_b *topo = (struct P_topo_b *)Map->plus.Line[line]->topo;
if (topo->left == 0 || topo->right == 0) {
G_debug(3, "line = %d left = %d right = %d", line,
topo->left, topo->right);
nerrors++;
}
}
}
if (nerrors)
G_warning(_("Skipping further checks because of incorrect boundaries"));
else {
int i, area, left, right, neighbour;
int nareas = Vect_get_num_areas(Map);
struct ilist *List = Vect_new_list();
nerrors = 0;
for (area = 1; area <= nareas; area++) {
if (!Vect_area_alive(Map, area))
continue;
line = Vect_get_area_centroid(Map, area);
if (line != 0)
continue; /* has centroid */
Vect_get_area_boundaries(Map, area, List);
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
Vect_get_line_areas(Map, abs(line), &left, &right);
if (line > 0)
neighbour = left;
else
neighbour = right;
if (neighbour < 0) {
neighbour = Vect_get_isle_area(Map, abs(neighbour));
if (!neighbour) {
/* borders outer void */
nerrors++;
if (Err) {
Vect_read_line(Map, Points, Cats, abs(line));
Vect_write_line(Err, GV_BOUNDARY, Points, Cats);
}
}
/* else neighbour is > 0, check below */
}
if (neighbour > 0) {
if (Vect_get_area_centroid(Map, neighbour) == 0) {
/* neighbouring area does not have a centroid either */
nerrors++;
if (Err) {
Vect_read_line(Map, Points, Cats, abs(line));
Vect_write_line(Err, GV_BOUNDARY, Points, Cats);
}
}
}
}
}
Vect_destroy_list(List);
if (nerrors)
G_warning(_("Number of redundant holes: %d"),
nerrors);
}
/* what else ? */
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 1;
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, Error;
struct line_pnts *Points;
struct line_cats *Cats;
int i, type, iter;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out, *error_out, *thresh_opt, *method_opt,
*look_ahead_opt;
struct Option *iterations_opt, *cat_opt, *alpha_opt, *beta_opt, *type_opt;
struct Option *field_opt, *where_opt, *reduction_opt, *slide_opt;
struct Option *angle_thresh_opt, *degree_thresh_opt,
*closeness_thresh_opt;
struct Option *betweeness_thresh_opt;
struct Flag *notab_flag, *loop_support_flag;
int with_z;
int total_input, total_output; /* Number of points in the input/output map respectively */
double thresh, alpha, beta, reduction, slide, angle_thresh;
double degree_thresh, closeness_thresh, betweeness_thresh;
int method;
int look_ahead, iterations;
int loop_support;
int layer;
int n_lines;
int simplification, mask_type;
struct cat_list *cat_list = NULL;
char *s, *descriptions;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("generalization"));
G_add_keyword(_("simplification"));
G_add_keyword(_("smoothing"));
G_add_keyword(_("displacement"));
G_add_keyword(_("network generalization"));
module->description = _("Performs vector based generalization.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary,area";
type_opt->answer = "line,boundary,area";
type_opt->guisection = _("Selection");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out->key = "error";
error_out->required = NO;
error_out->description =
_("Error map of all lines and boundaries not being generalized due to topology issues or over-simplification");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options =
"douglas,douglas_reduction,lang,reduction,reumann,boyle,sliding_averaging,distance_weighting,chaiken,hermite,snakes,network,displacement";
descriptions = NULL;
G_asprintf(&descriptions,
"douglas;%s;"
"douglas_reduction;%s;"
"lang;%s;"
"reduction;%s;"
"reumann;%s;"
"boyle;%s;"
"sliding_averaging;%s;"
"distance_weighting;%s;"
"chaiken;%s;"
"hermite;%s;"
"snakes;%s;"
"network;%s;"
"displacement;%s;",
_("Douglas-Peucker Algorithm"),
_("Douglas-Peucker Algorithm with reduction parameter"),
_("Lang Simplification Algorithm"),
_("Vertex Reduction Algorithm eliminates points close to each other"),
_("Reumann-Witkam Algorithm"),
_("Boyle's Forward-Looking Algorithm"),
_("McMaster's Sliding Averaging Algorithm"),
_("McMaster's Distance-Weighting Algorithm"),
_("Chaiken's Algorithm"),
_("Interpolation by Cubic Hermite Splines"),
_("Snakes method for line smoothing"),
_("Network generalization"),
_("Displacement of lines close to each other"));
method_opt->descriptions = G_store(descriptions);
method_opt->description = _("Generalization algorithm");
thresh_opt = G_define_option();
thresh_opt->key = "threshold";
thresh_opt->type = TYPE_DOUBLE;
thresh_opt->required = YES;
thresh_opt->options = "0-1000000000";
thresh_opt->description = _("Maximal tolerance value");
look_ahead_opt = G_define_option();
look_ahead_opt->key = "look_ahead";
look_ahead_opt->type = TYPE_INTEGER;
look_ahead_opt->required = NO;
look_ahead_opt->answer = "7";
look_ahead_opt->description = _("Look-ahead parameter");
reduction_opt = G_define_option();
reduction_opt->key = "reduction";
reduction_opt->type = TYPE_DOUBLE;
reduction_opt->required = NO;
reduction_opt->answer = "50";
reduction_opt->options = "0-100";
reduction_opt->description =
_("Percentage of the points in the output of 'douglas_reduction' algorithm");
slide_opt = G_define_option();
slide_opt->key = "slide";
slide_opt->type = TYPE_DOUBLE;
slide_opt->required = NO;
slide_opt->answer = "0.5";
slide_opt->options = "0-1";
slide_opt->description =
_("Slide of computed point toward the original point");
angle_thresh_opt = G_define_option();
angle_thresh_opt->key = "angle_thresh";
angle_thresh_opt->type = TYPE_DOUBLE;
angle_thresh_opt->required = NO;
angle_thresh_opt->answer = "3";
angle_thresh_opt->options = "0-180";
angle_thresh_opt->description =
_("Minimum angle between two consecutive segments in Hermite method");
degree_thresh_opt = G_define_option();
degree_thresh_opt->key = "degree_thresh";
degree_thresh_opt->type = TYPE_INTEGER;
degree_thresh_opt->required = NO;
degree_thresh_opt->answer = "0";
degree_thresh_opt->description =
_("Degree threshold in network generalization");
closeness_thresh_opt = G_define_option();
closeness_thresh_opt->key = "closeness_thresh";
closeness_thresh_opt->type = TYPE_DOUBLE;
closeness_thresh_opt->required = NO;
closeness_thresh_opt->answer = "0";
closeness_thresh_opt->options = "0-1";
closeness_thresh_opt->description =
_("Closeness threshold in network generalization");
betweeness_thresh_opt = G_define_option();
betweeness_thresh_opt->key = "betweeness_thresh";
betweeness_thresh_opt->type = TYPE_DOUBLE;
betweeness_thresh_opt->required = NO;
betweeness_thresh_opt->answer = "0";
betweeness_thresh_opt->description =
_("Betweeness threshold in network generalization");
alpha_opt = G_define_option();
alpha_opt->key = "alpha";
alpha_opt->type = TYPE_DOUBLE;
alpha_opt->required = NO;
alpha_opt->answer = "1.0";
alpha_opt->description = _("Snakes alpha parameter");
beta_opt = G_define_option();
beta_opt->key = "beta";
beta_opt->type = TYPE_DOUBLE;
beta_opt->required = NO;
beta_opt->answer = "1.0";
beta_opt->description = _("Snakes beta parameter");
iterations_opt = G_define_option();
iterations_opt->key = "iterations";
iterations_opt->type = TYPE_INTEGER;
iterations_opt->required = NO;
iterations_opt->answer = "1";
iterations_opt->description = _("Number of iterations");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
loop_support_flag = G_define_flag();
loop_support_flag->key = 'l';
loop_support_flag->label = _("Disable loop support");
loop_support_flag->description = _("Do not modify end points of lines forming a closed loop");
notab_flag = G_define_standard_flag(G_FLG_V_TABLE);
notab_flag->description = _("Do not copy attributes");
notab_flag->guisection = _("Attributes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
thresh = atof(thresh_opt->answer);
look_ahead = atoi(look_ahead_opt->answer);
alpha = atof(alpha_opt->answer);
beta = atof(beta_opt->answer);
reduction = atof(reduction_opt->answer);
iterations = atoi(iterations_opt->answer);
slide = atof(slide_opt->answer);
angle_thresh = atof(angle_thresh_opt->answer);
degree_thresh = atof(degree_thresh_opt->answer);
closeness_thresh = atof(closeness_thresh_opt->answer);
betweeness_thresh = atof(betweeness_thresh_opt->answer);
mask_type = type_mask(type_opt);
G_debug(3, "Method: %s", method_opt->answer);
s = method_opt->answer;
if (strcmp(s, "douglas") == 0)
method = DOUGLAS;
else if (strcmp(s, "lang") == 0)
method = LANG;
else if (strcmp(s, "reduction") == 0)
method = VERTEX_REDUCTION;
else if (strcmp(s, "reumann") == 0)
method = REUMANN;
else if (strcmp(s, "boyle") == 0)
method = BOYLE;
else if (strcmp(s, "distance_weighting") == 0)
method = DISTANCE_WEIGHTING;
else if (strcmp(s, "chaiken") == 0)
method = CHAIKEN;
else if (strcmp(s, "hermite") == 0)
method = HERMITE;
else if (strcmp(s, "snakes") == 0)
method = SNAKES;
else if (strcmp(s, "douglas_reduction") == 0)
method = DOUGLAS_REDUCTION;
else if (strcmp(s, "sliding_averaging") == 0)
method = SLIDING_AVERAGING;
else if (strcmp(s, "network") == 0)
method = NETWORK;
else if (strcmp(s, "displacement") == 0) {
method = DISPLACEMENT;
/* we can displace only the lines */
mask_type = GV_LINE;
}
else {
G_fatal_error(_("Unknown method"));
exit(EXIT_FAILURE);
}
/* simplification or smoothing? */
switch (method) {
case DOUGLAS:
case DOUGLAS_REDUCTION:
case LANG:
case VERTEX_REDUCTION:
case REUMANN:
simplification = 1;
break;
default:
simplification = 0;
break;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old2(&In, map_in->answer, "", field_opt->answer) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
if (Vect_get_num_primitives(&In, mask_type) == 0) {
G_warning(_("No lines found in input map <%s>"), map_in->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (error_out->answer) {
if (0 > Vect_open_new(&Error, error_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create error vector map <%s>"), error_out->answer);
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
total_input = total_output = 0;
layer = Vect_get_field_number(&In, field_opt->answer);
/* parse filter options */
if (layer > 0)
cat_list = Vect_cats_set_constraint(&In, layer,
where_opt->answer, cat_opt->answer);
if (method == DISPLACEMENT) {
/* modifies only lines, all other features including boundaries are preserved */
/* options where, cats, and layer are respected */
G_message(_("Displacement..."));
snakes_displacement(&In, &Out, thresh, alpha, beta, 1.0, 10.0,
iterations, cat_list, layer);
}
/* TODO: rearrange code below. It's really messy */
if (method == NETWORK) {
/* extracts lines of selected type, all other features are discarded */
/* options where, cats, and layer are ignored */
G_message(_("Network generalization..."));
total_output =
graph_generalization(&In, &Out, mask_type, degree_thresh,
closeness_thresh, betweeness_thresh);
}
/* copy tables here because method == NETWORK is complete and
* tables for Out may be needed for parse_filter_options() below */
if (!notab_flag->answer) {
if (method == NETWORK)
copy_tables_by_cats(&In, &Out);
else
Vect_copy_tables(&In, &Out, -1);
}
else if (where_opt->answer && method < NETWORK) {
G_warning(_("Attributes are needed for 'where' option, copying table"));
Vect_copy_tables(&In, &Out, -1);
}
/* smoothing/simplification */
if (method < NETWORK) {
/* modifies only lines of selected type, all other features are preserved */
int not_modified_boundaries = 0, n_oversimplified = 0;
struct line_pnts *APoints; /* original Points */
set_topo_debug();
Vect_copy_map_lines(&In, &Out);
Vect_build_partial(&Out, GV_BUILD_CENTROIDS);
G_message("-----------------------------------------------------");
G_message(_("Generalization (%s)..."), method_opt->answer);
G_message(_("Using threshold: %g %s"), thresh, G_database_unit_name(1));
G_percent_reset();
APoints = Vect_new_line_struct();
n_lines = Vect_get_num_lines(&Out);
for (i = 1; i <= n_lines; i++) {
int after = 0;
G_percent(i, n_lines, 1);
type = Vect_read_line(&Out, APoints, Cats, i);
if (!(type & GV_LINES) || !(mask_type & type))
continue;
if (layer > 0) {
if ((type & GV_LINE) &&
!Vect_cats_in_constraint(Cats, layer, cat_list))
continue;
else if ((type & GV_BOUNDARY)) {
int do_line = 0;
int left, right;
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
if (!do_line) {
/* check if any of the centroids is selected */
Vect_get_line_areas(&Out, i, &left, &right);
if (left < 0)
left = Vect_get_isle_area(&Out, abs(left));
if (right < 0)
right = Vect_get_isle_area(&Out, abs(right));
if (left > 0) {
Vect_get_area_cats(&Out, left, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
if (!do_line && right > 0) {
Vect_get_area_cats(&Out, right, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
}
if (!do_line)
continue;
}
}
Vect_line_prune(APoints);
if (APoints->n_points < 2)
/* Line of length zero, delete if boundary ? */
continue;
total_input += APoints->n_points;
/* copy points */
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
loop_support = 0;
if (!loop_support_flag->answer) {
int n1, n2;
Vect_get_line_nodes(&Out, i, &n1, &n2);
if (n1 == n2) {
if (Vect_get_node_n_lines(&Out, n1) == 2) {
if (abs(Vect_get_node_line(&Out, n1, 0)) == i &&
abs(Vect_get_node_line(&Out, n1, 1)) == i)
loop_support = 1;
}
}
}
for (iter = 0; iter < iterations; iter++) {
switch (method) {
case DOUGLAS:
douglas_peucker(Points, thresh, with_z);
break;
case DOUGLAS_REDUCTION:
douglas_peucker_reduction(Points, thresh, reduction,
with_z);
break;
case LANG:
lang(Points, thresh, look_ahead, with_z);
break;
case VERTEX_REDUCTION:
vertex_reduction(Points, thresh, with_z);
break;
case REUMANN:
reumann_witkam(Points, thresh, with_z);
break;
case BOYLE:
boyle(Points, look_ahead, loop_support, with_z);
break;
case SLIDING_AVERAGING:
sliding_averaging(Points, slide, look_ahead, loop_support, with_z);
break;
case DISTANCE_WEIGHTING:
distance_weighting(Points, slide, look_ahead, loop_support, with_z);
break;
case CHAIKEN:
chaiken(Points, thresh, loop_support, with_z);
break;
case HERMITE:
hermite(Points, thresh, angle_thresh, loop_support, with_z);
break;
case SNAKES:
snakes(Points, alpha, beta, loop_support, with_z);
break;
}
}
if (loop_support == 0) {
/* safety check, BUG in method if not passed */
if (APoints->x[0] != Points->x[0] ||
APoints->y[0] != Points->y[0] ||
APoints->z[0] != Points->z[0])
G_fatal_error(_("Method '%s' did not preserve first point"), method_opt->answer);
if (APoints->x[APoints->n_points - 1] != Points->x[Points->n_points - 1] ||
APoints->y[APoints->n_points - 1] != Points->y[Points->n_points - 1] ||
APoints->z[APoints->n_points - 1] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve last point"), method_opt->answer);
}
else {
/* safety check, BUG in method if not passed */
if (Points->x[0] != Points->x[Points->n_points - 1] ||
Points->y[0] != Points->y[Points->n_points - 1] ||
Points->z[0] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve loop"), method_opt->answer);
}
Vect_line_prune(Points);
/* oversimplified line */
if (Points->n_points < 2) {
after = APoints->n_points;
n_oversimplified++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
/* check for topology corruption */
else if (type == GV_BOUNDARY) {
if (!check_topo(&Out, i, APoints, Points, Cats)) {
after = APoints->n_points;
not_modified_boundaries++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
else
after = Points->n_points;
}
else {
/* type == GV_LINE */
Vect_rewrite_line(&Out, i, type, Points, Cats);
after = Points->n_points;
}
total_output += after;
}
if (not_modified_boundaries > 0)
G_warning(_("%d boundaries were not modified because modification would damage topology"),
not_modified_boundaries);
if (n_oversimplified > 0)
G_warning(_("%d lines/boundaries were not modified due to over-simplification"),
n_oversimplified);
G_message("-----------------------------------------------------");
/* make sure that clean topo is built at the end */
Vect_build_partial(&Out, GV_BUILD_NONE);
if (error_out->answer)
Vect_build_partial(&Error, GV_BUILD_NONE);
}
Vect_build(&Out);
if (error_out->answer)
Vect_build(&Error);
Vect_close(&In);
Vect_close(&Out);
if (error_out->answer)
Vect_close(&Error);
G_message("-----------------------------------------------------");
if (total_input != 0 && total_input != total_output)
G_done_msg(_("Number of vertices for selected features %s from %d to %d (%d%% remaining)"),
simplification ? _("reduced") : _("changed"),
total_input, total_output,
(total_output * 100) / total_input);
else
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
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);
}
/*!
\brief Copy all alive vector features from given layer of opened
vector map to another opened vector map
\param In input vector map
\param field layer number (-1 for all layers)
\param[out] Out output vector map
\return 0 on success
\return 1 on error
*/
int Vect_copy_map_lines_field(struct Map_info *In, int field,
struct Map_info *Out)
{
int i, type, nlines, ret, left, rite, centroid;
struct line_pnts *Points, *CPoints;
struct line_cats *Cats, *CCats;
Points = Vect_new_line_struct();
CPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
CCats = Vect_new_cats_struct();
if (Vect_level(In) < 1)
G_fatal_error("Vect_copy_map_lines(): %s",
_("input vector map is not open"));
ret = 0;
/* Note: sometimes is important to copy on level 2 (pseudotopo centroids)
* and sometimes on level 1 if build take too long time */
if (Vect_level(In) >= 2) {
nlines = Vect_get_num_lines(In);
for (i = 1; i <= nlines; i++) {
if (!Vect_line_alive(In, i))
continue;
type = Vect_read_line(In, Points, Cats, i);
if (type == -1) {
G_warning(_("Unable to read vector map <%s>"),
Vect_get_full_name(In));
ret = 1;
break;
}
if (type == 0)
continue; /* dead line */
/* don't skips boundaries if field != -1 */
if (field != -1) {
if (type & GV_BOUNDARY) {
if (Vect_cat_get(Cats, field, NULL) == 0) {
int skip_bndry = 1;
Vect_get_line_areas(In, i, &left, &rite);
if (left < 0)
left = Vect_get_isle_area(In, abs(left));
if (left > 0) {
if ((centroid =
Vect_get_area_centroid(In, left)) > 0) {
Vect_read_line(In, CPoints, CCats, centroid);
if (Vect_cat_get(CCats, field, NULL) != 0)
skip_bndry = 0;
}
}
if (skip_bndry) {
if (rite < 0)
rite = Vect_get_isle_area(In, abs(rite));
if (rite > 0) {
if ((centroid =
Vect_get_area_centroid(In, rite)) > 0) {
Vect_read_line(In, CPoints, CCats,
centroid);
if (Vect_cat_get(CCats, field, NULL) != 0)
skip_bndry = 0;
}
}
}
if (skip_bndry)
continue;
}
}
else if (Vect_cat_get(Cats, field, NULL) == 0)
continue; /* different layer */
}
Vect_write_line(Out, type, Points, Cats);
}
}
else { /* Level 1 */
Vect_rewind(In);
while (1) {
type = Vect_read_next_line(In, Points, Cats);
if (type == -1) {
G_warning(_("Unable to read vector map <%s>"),
Vect_get_full_name(In));
ret = 1;
break;
}
else if (type == -2) { /* EOF */
break;
}
else if (type == 0) { /* dead line */
continue;
}
/* don't skip boundaries if field != -1 */
if (field != -1 && !(type & GV_BOUNDARY) &&
Vect_cat_get(Cats, field, NULL) == 0)
continue; /* different layer */
Vect_write_line(Out, type, Points, Cats);
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(CPoints);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(CCats);
return ret;
}
/* check topology corruption by boundary modification
* return 0 on corruption, 1 if modification is ok */
int check_topo(struct Map_info *Out, int line, struct line_pnts *APoints,
struct line_pnts *Points, struct line_cats *Cats)
{
int i, j, intersect, newline, left_old, right_old,
left_new, right_new;
struct bound_box box;
struct line_pnts **AXLines, **BXLines;
int naxlines, nbxlines;
static struct line_pnts *BPoints = NULL;
static struct boxlist *List = NULL;
if (!BPoints)
BPoints = Vect_new_line_struct();
if (!List)
List = Vect_new_boxlist(1);
Vect_line_box(Points, &box);
/* Check the modified boundary for self-intersection */
AXLines = BXLines = NULL;
Vect_line_intersection2(Points, NULL, &box, &box, &AXLines, &BXLines,
&naxlines, &nbxlines, 0);
/* Free */
if (naxlines > 0) {
for (j = 0; j < naxlines; j++) {
Vect_destroy_line_struct(AXLines[j]);
}
}
if (AXLines)
G_free(AXLines);
if (naxlines > 0)
return 0;
/* Check intersection of the modified boundary with other boundaries */
Vect_select_lines_by_box(Out, &box, GV_BOUNDARY, List);
intersect = 0;
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->id[i];
if (bline == line)
continue;
Vect_read_line(Out, BPoints, NULL, bline);
/* Vect_line_intersection is quite slow, hopefully not so bad because only few
* intersections should be found if any */
AXLines = BXLines = NULL;
Vect_line_intersection2(Points, BPoints, &box, &List->box[i],
&AXLines, &BXLines,
&naxlines, &nbxlines, 0);
G_debug(4,
"bline = %d intersect = %d naxlines = %d nbxlines = %d",
bline, intersect, naxlines, nbxlines);
/* Free */
if (naxlines > 0) {
for (j = 0; j < naxlines; j++) {
Vect_destroy_line_struct(AXLines[j]);
}
}
if (AXLines)
G_free(AXLines);
if (nbxlines > 0) {
for (j = 0; j < nbxlines; j++) {
Vect_destroy_line_struct(BXLines[j]);
}
}
if (BXLines)
G_free(BXLines);
if (naxlines > 1 || nbxlines > 1) {
intersect = 1;
break;
}
}
/* modified boundary intersects another boundary */
if (intersect)
return 0;
/* Get centroids on the left and right side */
Vect_get_line_areas(Out, line, &left_old, &right_old);
if (left_old < 0)
left_old = Vect_get_isle_area(Out, abs(left_old));
if (left_old > 0)
left_old = Vect_get_area_centroid(Out, left_old);
if (right_old < 0)
right_old = Vect_get_isle_area(Out, abs(right_old));
if (right_old > 0)
right_old = Vect_get_area_centroid(Out, right_old);
/* OK, rewrite modified boundary */
newline = Vect_rewrite_line(Out, line, GV_BOUNDARY, Points, Cats);
/* Check position of centroids */
Vect_get_line_areas(Out, newline, &left_new, &right_new);
if (left_new < 0)
left_new = Vect_get_isle_area(Out, abs(left_new));
if (left_new > 0)
left_new = Vect_get_area_centroid(Out, left_new);
if (right_new < 0)
right_new = Vect_get_isle_area(Out, abs(right_new));
if (right_new > 0)
right_new = Vect_get_area_centroid(Out, right_new);
if (left_new != left_old || right_new != right_old) {
G_debug(3,
"The modified boundary changes attachment of centroid -> not modified");
Vect_rewrite_line(Out, newline, GV_BOUNDARY, APoints, Cats);
return 0;
}
return 1;
}
/*!
\brief Write data to GRASS ASCII vector format
Prints message if some features without category are skipped.
\param[out] ascii pointer to the output ASCII file
\param[out] att att file (< version 5 only)
\param Map pointer to Map_info structure
\param ver version number 4 or 5
\param format format GV_ASCII_FORMAT_POINT or GV_ASCII_FORMAT_STD
\param dp number of significant digits
\param fs field separator
\param region_flag check region
\param type feature type filter
\param field field number
\param Clist list of categories to filter features or NULL
\param where SQL select where statement to filter features or NULL
\param column_names array of columns to be included to the output or NULL
"*" as the first item in the array indicates all columns
\param header TRUE to print also header
\return number of written features
\return -1 on error
*/
int Vect_write_ascii(FILE *ascii,
FILE *att, struct Map_info *Map, int ver,
int format, int dp, char *fs, int region_flag, int type,
int field, const struct cat_list *Clist, const char* where,
const char **column_names, int header)
{
int ltype, ctype, i, cat, line, left, right, found;
double *xptr, *yptr, *zptr, x, y;
static struct line_pnts *Points;
struct line_cats *Cats, *ACats;
char *xstring, *ystring, *zstring;
size_t xsize, ysize, zsize;
struct Cell_head window;
struct ilist *fcats;
int count, n_skipped;
/* where || columns */
struct field_info *Fi;
dbDriver *driver;
dbValue value;
dbHandle handle;
int *cats, ncats, more;
dbTable *Table;
dbString dbstring;
dbColumn *Column;
dbValue *Value;
char *buf;
size_t bufsize;
dbCursor cursor;
/* columns */
char **columns;
int *coltypes;
char *all_columns;
Fi = NULL;
driver = NULL;
columns = NULL;
coltypes = NULL;
all_columns = NULL;
G_zero(&value, sizeof(dbValue));
db_init_string(&dbstring);
xstring = NULL;
ystring = NULL;
zstring = NULL;
xsize = 0;
ysize = 0;
zsize = 0;
buf = NULL;
bufsize = 0;
/* get the region */
G_get_window(&window);
count = ncats = 0;
xstring = ystring = zstring = NULL;
cats = NULL;
if (field > 0 && (where || column_names)) {
Fi = Vect_get_field(Map, field);
if (!Fi) {
G_fatal_error(_("Database connection not defined for layer %d"),
field);
}
driver = db_start_driver(Fi->driver);
if (!driver)
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
db_init_handle(&handle);
db_set_handle(&handle, Fi->database, NULL);
if (db_open_database(driver, &handle) != DB_OK)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* select cats (sorted array) */
ncats = db_select_int(driver, Fi->table, Fi->key, where, &cats);
G_debug(3, "%d categories selected from table <%s>", ncats, Fi->table);
if (!column_names) {
db_close_database(driver);
db_shutdown_driver(driver);
}
else {
int icol, ncols;
const char *col_name;
int len_all = 0;
db_set_string(&dbstring, Fi->table);
if (db_describe_table(driver, &dbstring, &Table) != DB_OK) {
G_warning(_("Unable to describe table <%s>"), Fi->table);
return -1;
}
ncols = db_get_table_number_of_columns(Table);
columns = (char **) G_malloc((ncols + 1) * sizeof(char *));
if (column_names[0] && strcmp(column_names[0], "*") == 0) {
/* all columns */
icol = 0;
for (i = 0; i < ncols; i++) {
col_name = db_get_column_name(db_get_table_column(Table, i));
/* key column skipped */
if (strcmp(Fi->key, col_name) != 0)
columns[icol++] = G_store(col_name);
}
columns[icol] = NULL;
}
else {
int j;
icol = 0;
i = 0;
while (column_names[i]) {
/* key column skipped */
if (strcmp(Fi->key, column_names[i]) != 0) {
found = 0;
for (j = 0; j < ncols; j++) {
col_name = db_get_column_name(db_get_table_column(Table, j));
if (strcmp(col_name, column_names[i]) == 0) {
columns[icol++] = G_store(col_name);
found = 1;
break;
}
}
if (!found) {
G_warning(_("Column <%s> does not exist"),
column_names[i]);
G_important_message(_("Available columns:"));
for (j = 0; j < ncols; j++) {
col_name = db_get_column_name(db_get_table_column(Table, j));
G_important_message("%s", col_name);
}
G_warning(_("Export cancelled"));
db_close_database(driver);
db_shutdown_driver(driver);
return -1;
}
}
i++;
}
columns[icol] = NULL;
}
db_zero_string(&dbstring);
db_free_table(Table);
Table = NULL;
if (columns[0]) {
/* selected columns only */
i = 0;
while (columns[i])
len_all += strlen(columns[i++]);
coltypes = G_malloc(i * sizeof(int));
all_columns = G_malloc(len_all + i + 2);
i = 0;
strcpy(all_columns, columns[0]);
while (columns[i]) {
/* get column types */
coltypes[i] = db_column_Ctype(driver, Fi->table, columns[i]);
if (coltypes[i] < 0) {
db_close_database(driver);
db_shutdown_driver(driver);
G_warning(_("Unknown type of column <%s>, export cancelled"),
columns[i]);
return -1;
}
if (i > 0) {
strcat(all_columns, ",");
strcat(all_columns, columns[i]);
}
i++;
}
}
else {
/* no column or only key column selected */
G_free(columns);
columns = NULL;
db_close_database(driver);
db_shutdown_driver(driver);
}
}
}
if (format == GV_ASCII_FORMAT_POINT && header) {
/* print header */
if (Map->head.with_z)
fprintf(ascii, "east%snorth%sheight%scat", fs, fs, fs);
else
fprintf(ascii, "east%snorth%scat", fs, fs);
if (columns) {
for (i = 0; columns[i]; i++) {
if (db_select_value
(driver, Fi->table, Fi->key, cat,
columns[i], &value) < 0)
G_fatal_error(_("Unable to select record from table <%s> (key %s, column %s)"),
Fi->table, Fi->key, columns[i]);
if (columns[i])
fprintf(ascii, "%s%s", fs, columns[i]);
else
fprintf(ascii, "%s", columns[i]); /* can not happen */
}
}
fprintf(ascii, "%s", HOST_NEWLINE);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ACats = Vect_new_cats_struct();
fcats = Vect_new_list();
/* by default, read_next_line will NOT read Dead lines */
/* but we can override that (in Level I only) by specifying */
/* the type -1, which means match all line types */
Vect_rewind(Map);
count = n_skipped = line = 0;
while (TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1 ) { /* failure */
if (columns) {
db_close_database(driver);
db_shutdown_driver(driver);
free_col_arrays(coltypes, all_columns,
column_names && strcmp(column_names[0], "*") == 0 ? columns : NULL);
}
return -1;
}
if (ltype == -2) { /* EOF */
if (columns) {
db_close_database(driver);
db_shutdown_driver(driver);
free_col_arrays(coltypes, all_columns,
column_names && strcmp(column_names[0], "*") == 0 ? columns : NULL);
}
break;
}
line++;
if (!(ltype & type))
continue;
if (format == GV_ASCII_FORMAT_POINT && !(ltype & GV_POINTS))
continue;
found = get_cat(Cats, Clist, cats, ncats, field, &cat);
if (!found && field > 0 && ltype == GV_BOUNDARY &&
type & GV_AREA && Vect_level(Map) > 1) {
Vect_get_line_areas(Map, line, &left, &right);
if (left < 0)
left = Vect_get_isle_area(Map, abs(left));
if (left > 0) {
Vect_get_area_cats(Map, left, ACats);
found = get_cat(ACats, Clist, cats, ncats, field, &cat);
}
if (right < 0)
right = Vect_get_isle_area(Map, abs(right));
if (!found && right > 0) {
Vect_get_area_cats(Map, right, ACats);
found = get_cat(ACats, Clist, cats, ncats, field, &cat);
}
}
if (!found) {
if (Cats->n_cats < 1)
n_skipped++;
continue;
}
if (ver < 5) {
Vect_cat_get(Cats, 1, &cat);
}
switch (ltype) {
case GV_BOUNDARY:
if (ver == 5)
ctype = 'B';
else
ctype = 'A';
break;
case GV_CENTROID:
if (ver < 5) {
if (att != NULL) {
if (cat > 0) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
fprintf(att, "A %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
}
continue;
}
ctype = 'C';
break;
case GV_LINE:
ctype = 'L';
break;
case GV_POINT:
ctype = 'P';
break;
case GV_FACE:
ctype = 'F';
break;
case GV_KERNEL:
ctype = 'K';
break;
default:
ctype = 'X';
G_warning(_("Unknown feature type %d"), (int)ltype);
break;
}
if (format == GV_ASCII_FORMAT_POINT) {
if (region_flag) {
if ((window.east < Points->x[0]) ||
(window.west > Points->x[0]))
continue;
}
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
if (region_flag) {
if ((window.north < Points->y[0]) ||
(window.south > Points->y[0]))
continue;
}
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
Vect_field_cat_get(Cats, field, fcats);
if (Map->head.with_z && ver == 5) {
if (region_flag) {
if ((window.top < Points->z[0]) ||
(window.bottom > Points->z[0]))
continue;
}
G_rasprintf(&zstring, &zsize, "%.*f", dp, Points->z[0]);
G_trim_decimal(zstring);
fprintf(ascii, "%s%s%s%s%s", xstring, fs, ystring, fs,
zstring);
}
else {
fprintf(ascii, "%s%s%s", xstring, fs, ystring);
}
if (fcats->n_values > 0 && cat > -1) {
if (fcats->n_values > 1) {
G_warning(_("Feature has more categories. Only one category (%d) "
"is exported."), cat);
}
fprintf(ascii, "%s%d", fs, cat);
/* print attributes */
if (columns) {
G_rasprintf(&buf, &bufsize, "SELECT %s FROM %s WHERE %s = %d",
all_columns, Fi->table, Fi->key, cat);
G_debug(2, "SQL: %s", buf);
db_set_string(&dbstring, buf);
if (db_open_select_cursor
(driver, &dbstring, &cursor, DB_SEQUENTIAL) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Cannot select attributes for cat = %d"),
cat);
}
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK) {
db_close_database(driver);
db_shutdown_driver(driver);
G_fatal_error(_("Unable to fetch data from table"));
}
Table = db_get_cursor_table(&cursor);
for (i = 0; columns[i]; i++) {
Column = db_get_table_column(Table, i);
Value = db_get_column_value(Column);
if (db_test_value_isnull(Value)) {
fprintf(ascii, "%s", fs);
}
else {
switch(coltypes[i])
{
case DB_C_TYPE_INT: {
fprintf(ascii, "%s%d", fs, db_get_value_int(Value));
break;
}
case DB_C_TYPE_DOUBLE: {
fprintf(ascii, "%s%.*f", fs, dp, db_get_value_double(Value));
break;
}
case DB_C_TYPE_STRING: {
fprintf(ascii, "%s%s", fs, db_get_value_string(Value));
break;
}
case DB_C_TYPE_DATETIME: {
break;
}
case -1:
G_fatal_error(_("Column <%s> not found in table <%s>"),
columns[i], Fi->table);
default: G_fatal_error(_("Column <%s>: unsupported data type"),
columns[i]);
}
}
}
db_close_cursor(&cursor);
}
}
fprintf(ascii, "%s", HOST_NEWLINE);
}
else if (format == GV_ASCII_FORMAT_STD) {
/* FORMAT_STANDARD */
if (ver == 5 && Cats->n_cats > 0)
fprintf(ascii, "%c %d %d%s", ctype, Points->n_points,
Cats->n_cats, HOST_NEWLINE);
else
fprintf(ascii, "%c %d%s", ctype, Points->n_points, HOST_NEWLINE);
xptr = Points->x;
yptr = Points->y;
zptr = Points->z;
while (Points->n_points--) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, *xptr++);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, *yptr++);
G_trim_decimal(ystring);
if (ver == 5) {
if (Map->head.with_z) {
G_rasprintf(&zstring, &zsize, "%.*f", dp, *zptr++);
G_trim_decimal(zstring);
fprintf(ascii, " %-12s %-12s %-12s%s", xstring,
ystring, zstring, HOST_NEWLINE);
}
else {
fprintf(ascii, " %-12s %-12s%s", xstring, ystring, HOST_NEWLINE);
}
} /*Version 4 */
else {
fprintf(ascii, " %-12s %-12s%s", ystring, xstring, HOST_NEWLINE);
}
}
if (ver == 5) {
for (i = 0; i < Cats->n_cats; i++) {
fprintf(ascii, " %-5d %-10d%s", Cats->field[i],
Cats->cat[i], HOST_NEWLINE);
}
}
else {
if (cat > -1) {
if (ltype == GV_POINT) {
G_rasprintf(&xstring, &xsize, "%.*f", dp, Points->x[0]);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, Points->y[0]);
G_trim_decimal(ystring);
fprintf(att, "P %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
else {
x = (Points->x[1] + Points->x[0]) / 2;
y = (Points->y[1] + Points->y[0]) / 2;
G_rasprintf(&xstring, &xsize, "%.*f", dp, x);
G_trim_decimal(xstring);
G_rasprintf(&ystring, &ysize, "%.*f", dp, y);
G_trim_decimal(ystring);
fprintf(att, "L %s %s %d%s", xstring, ystring, cat, HOST_NEWLINE);
}
}
}
}
else if (format == GV_ASCII_FORMAT_WKT) {
if (ltype & (GV_BOUNDARY | GV_CENTROID | GV_FACE | GV_KERNEL))
continue;
/* Well-Known Text */
Vect_sfa_line_astext(Points, ltype, Vect_is_3d(Map), dp, ascii);
count++;
}
else {
G_fatal_error(_("Unknown format"));
}
count++;
}
if (format == GV_ASCII_FORMAT_WKT) {
/* process areas - topology required */
int i, area, nareas, isle, nisles;
if (Vect_level(Map) < 2) {
G_warning(_("Topology not available, unable to process areas"));
nareas = 0;
}
else {
nareas = Vect_get_num_areas(Map);
}
for (area = 1; area <= nareas; area++) {
if (!Vect_area_alive(Map, area)) /* skip dead areas */
continue;
if (Vect_get_area_cat(Map, area, field) < 0)
continue;
/* get boundary -> linearring */
if (Vect_get_area_points(Map, area, Points) < 0) {
G_warning(_("Unable to get boundary of area id %d"), area);
continue;
}
fprintf(ascii, "POLYGON(");
/* write outter ring */
Vect_sfa_line_astext(Points, GV_BOUNDARY, 0, dp, ascii); /* boundary is always 2D */
/* get isles (holes) -> inner rings */
nisles = Vect_get_area_num_isles(Map, area);
for (i = 0; i < nisles; i++) {
/* get isle boundary -> linearring */
isle = Vect_get_area_isle(Map, area, i);
if (Vect_get_isle_points(Map, isle, Points) < 0) {
G_warning(_("Unable to get boundary of isle id %d (area id %d)"), isle, area);
continue;
}
fprintf(ascii, ", ");
/* write inner ring */
Vect_sfa_line_astext(Points, GV_BOUNDARY, 0, dp, ascii); /* boundary is always 2D */
}
fprintf(ascii, ")%s", HOST_NEWLINE);
count++;
}
}
if (n_skipped > 0)
G_important_message(_("%d features without category skipped. To export also "
"features without category use '%s=-1'."), n_skipped, "layer");
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(ACats);
return count;
}