/*!
\brief Copy tables linked to vector map.
All if field = 0, or table defined by given field if field > 0
Notice, that if input map has no tables defined, it will copy
nothing and return 0 (success).
\param In input vector map
\param[out] Out output vector map
\param field layer number
\return 0 on success
\return -1 on error
*/
int Vect_copy_tables(const struct Map_info *In, struct Map_info *Out,
int field)
{
int i, n, ret, type;
struct field_info *Fi, *Fin;
dbDriver *driver;
n = Vect_get_num_dblinks(In);
G_debug(2, "Vect_copy_tables(): copying %d tables", n);
type = GV_1TABLE;
if (n > 1)
type = GV_MTABLE;
for (i = 0; i < n; i++) {
Fi = Vect_get_dblink(In, i);
if (Fi == NULL) {
G_warning(_("Database connection not defined for layer %d"),
In->dblnk->field[i].number);
return -1;
}
if (field > 0 && Fi->number != field)
continue;
Fin = Vect_default_field_info(Out, Fi->number, Fi->name, type);
G_debug(2, "Copy drv:db:table '%s:%s:%s' to '%s:%s:%s'",
Fi->driver, Fi->database, Fi->table, Fin->driver,
Fin->database, Fin->table);
ret =
Vect_map_add_dblink(Out, Fi->number, Fi->name, Fin->table,
Fi->key, Fin->database, Fin->driver);
if (ret == -1) {
G_warning(_("Unable to add database link for vector map <%s>"),
Out->name);
return -1;
}
ret = db_copy_table(Fi->driver, Fi->database, Fi->table,
Fin->driver, Vect_subst_var(Fin->database, Out),
Fin->table);
if (ret == DB_FAILED) {
G_warning(_("Unable to copy table <%s>"), Fin->table);
return -1;
}
driver =
db_start_driver_open_database(Fin->driver,
Vect_subst_var(Fin->database, Out));
if (driver == NULL) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fin->database, Fin->driver);
}
else {
if (db_create_index2(driver, Fin->table, Fi->key) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fin->table, Fin->key);
db_close_database_shutdown_driver(driver);
}
}
return 0;
}
/*!
\brief Rename a map.
Attribute tables are created in the same database where input tables were stored.
The original format (native/OGR) is used.
Old map ('out') is deleted!!!
\param in input vector map name
\param out output vector map name
\return -1 error
\return 0 success
*/
int Vect_rename(const char *in, const char *out)
{
int i, n, ret, type;
struct Map_info Map;
struct field_info *Fin, *Fout;
int *fields;
dbDriver *driver;
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
G_debug(2, "Rename vector '%s' to '%s'", in, out);
/* check for [A-Za-z][A-Za-z0-9_]* in name */
if (Vect_legal_filename(out) < 0)
G_fatal_error(_("Vector map name is not SQL compliant"));
/* Delete old vector if it exists */
if (G_find_vector2(out, G_mapset())) {
G_warning(_("Vector map <%s> already exists and will be overwritten"),
out);
Vect_delete(out);
}
/* remove mapset from fully qualified name */
if (G_name_is_fully_qualified(in, xname, xmapset)) {
in = xname;
}
/* Move the directory */
ret = G_rename(GV_DIRECTORY, in, out);
if (ret == 0) {
G_warning(_("Vector map <%s> not found"), in);
return -1;
}
else if (ret == -1) {
G_warning(_("Unable to copy vector map <%s> to <%s>"), in, out);
return -1;
}
/* Rename all tables if the format is native */
Vect_set_open_level(1);
Vect_open_update_head(&Map, out, G_mapset());
if (Map.format != GV_FORMAT_NATIVE) { /* Done */
Vect_close(&Map);
return 0;
}
/* Copy tables */
n = Vect_get_num_dblinks(&Map);
type = GV_1TABLE;
if (n > 1)
type = GV_MTABLE;
/* Make the list of fields */
fields = (int *)G_malloc(n * sizeof(int));
for (i = 0; i < n; i++) {
Fin = Vect_get_dblink(&Map, i);
fields[i] = Fin->number;
}
for (i = 0; i < n; i++) {
G_debug(3, "field[%d] = %d", i, fields[i]);
Fin = Vect_get_field(&Map, fields[i]);
if (Fin == NULL) {
G_warning(_("Database connection not defined for layer %d"),
fields[i]);
Vect_close(&Map);
return -1;
}
Fout = Vect_default_field_info(&Map, Fin->number, Fin->name, type);
G_debug(3, "Copy drv:db:table '%s:%s:%s' to '%s:%s:%s'",
Fin->driver, Fin->database, Fin->table, Fout->driver,
Fout->database, Fout->table);
/* TODO: db_rename_table instead of db_copy_table */
ret = db_copy_table(Fin->driver, Fin->database, Fin->table,
Fout->driver, Vect_subst_var(Fout->database,
&Map), Fout->table);
if (ret == DB_FAILED) {
G_warning(_("Unable to copy table <%s>"), Fin->table);
Vect_close(&Map);
return -1;
}
/* Change the link */
Vect_map_del_dblink(&Map, Fin->number);
Vect_map_add_dblink(&Map, Fout->number, Fout->name, Fout->table,
Fin->key, Fout->database, Fout->driver);
/* Delete old table */
ret = db_delete_table(Fin->driver, Fin->database, Fin->table);
if (ret == DB_FAILED) {
G_warning(_("Unable to delete table <%s>"), Fin->table);
Vect_close(&Map);
return -1;
}
driver =
db_start_driver_open_database(Fout->driver,
Vect_subst_var(Fout->database,
&Map));
if (driver == NULL) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fout->database, Fout->driver);
}
else {
if (db_create_index2(driver, Fout->table, Fin->key) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fout->table, Fout->key);
db_close_database_shutdown_driver(driver);
}
}
Vect_close(&Map);
free(fields);
return 0;
}
int main(int argc, char **argv)
{
int field, type, vertex_type;
double dmax;
char buf[DB_SQL_MAX];
struct {
struct Option *input, *output, *type, *dmax, *lfield, *use;
} opt;
struct {
struct Flag *table, *inter;
} flag;
struct GModule *module;
struct Map_info In, Out;
struct line_cats *LCats;
struct line_pnts *LPoints;
dbDriver *driver;
struct field_info *Fi;
dbString stmt;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword("3D");
G_add_keyword(_("node"));
G_add_keyword(_("vertex"));
module->description =
_("Creates points along input lines in new vector map with 2 layers.");
opt.input = G_define_standard_option(G_OPT_V_INPUT);
opt.lfield = G_define_standard_option(G_OPT_V_FIELD);
opt.lfield->key = "llayer";
opt.lfield->answer = "1";
opt.lfield->label = "Line layer number or name";
opt.lfield->guisection = _("Selection");
opt.type = G_define_standard_option(G_OPT_V3_TYPE);
opt.type->answer = "point,line,boundary,centroid,face";
opt.type->guisection = _("Selection");
opt.output = G_define_standard_option(G_OPT_V_OUTPUT);
opt.use = G_define_option();
opt.use->key = "use";
opt.use->type = TYPE_STRING;
opt.use->required = NO;
opt.use->description = _("Use line nodes or vertices only");
opt.use->options = "node,vertex";
opt.dmax = G_define_option();
opt.dmax->key = "dmax";
opt.dmax->type = TYPE_DOUBLE;
opt.dmax->required = NO;
opt.dmax->answer = "100";
opt.dmax->description = _("Maximum distance between points in map units");
flag.inter = G_define_flag();
flag.inter->key = 'i';
flag.inter->description = _("Interpolate points between line vertices (only for use=vertex)");
flag.table = G_define_standard_flag(G_FLG_V_TABLE);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
LCats = Vect_new_cats_struct();
LPoints = Vect_new_line_struct();
db_init_string(&stmt);
type = Vect_option_to_types(opt.type);
dmax = atof(opt.dmax->answer);
vertex_type = 0;
if (opt.use->answer) {
if (opt.use->answer[0] == 'n')
vertex_type = GV_NODE;
else
vertex_type = GV_VERTEX;
}
Vect_check_input_output_name(opt.input->answer, opt.output->answer,
G_FATAL_EXIT);
/* Open input lines */
Vect_set_open_level(2);
if (Vect_open_old2(&In, opt.input->answer, "", opt.lfield->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
Vect_set_error_handler_io(&In, &Out);
field = Vect_get_field_number(&In, opt.lfield->answer);
/* Open output segments */
if (Vect_open_new(&Out, opt.output->answer, Vect_is_3d(&In)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Table */
Fi = NULL;
if (!flag.table->answer) {
struct field_info *Fin;
/* copy input table */
Fin = Vect_get_field(&In, field);
if (Fin) { /* table defined */
int ret;
Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key,
Fi->database, Fi->driver);
ret = db_copy_table(Fin->driver, Fin->database, Fin->table,
Fi->driver, Vect_subst_var(Fi->database,
&Out), Fi->table);
if (ret == DB_FAILED) {
G_fatal_error(_("Unable to copy table <%s>"),
Fin->table);
}
}
Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 2, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
/* Open driver */
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver);
if (field == -1)
sprintf(buf,
"create table %s ( cat int, along double precision )",
Fi->table);
else
sprintf(buf,
"create table %s ( cat int, lcat int, along double precision )",
Fi->table);
db_append_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK) {
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, GV_KEY_COLUMN);
if (db_grant_on_table (driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
if (type & (GV_POINTS | GV_LINES | GV_FACE)) {
int line, nlines, nskipped;
nskipped = 0;
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype, cat;
G_debug(3, "line = %d", line);
G_percent(line, nlines, 2);
ltype = Vect_read_line(&In, LPoints, LCats, line);
if (!(ltype & type))
continue;
if (!Vect_cat_get(LCats, field, &cat) && field != -1) {
nskipped++;
continue;
}
/* Assign CAT for layer 0 objects (i.e. boundaries) */
if (field == -1)
cat = -1;
if (LPoints->n_points <= 1) {
write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0],
cat, 0.0, driver, Fi);
}
else { /* lines */
write_line(&Out, LPoints, cat, vertex_type,
flag.inter->answer, dmax, driver, Fi);
}
}
if (nskipped > 0)
G_warning(_("%d features without category in layer <%d> skipped. "
"Note that features without category (usually boundaries) are not "
"skipped when '%s=-1' is given."),
nskipped, field, opt.lfield->key);
}
if (type == GV_AREA) {
int area, nareas, centroid, cat;
nareas = Vect_get_num_areas(&In);
for (area = 1; area <= nareas; area++) {
int i, isle, nisles;
G_percent(area, nareas, 2);
centroid = Vect_get_area_centroid(&In, area);
cat = -1;
if (centroid > 0) {
Vect_read_line(&In, NULL, LCats, centroid);
if (!Vect_cat_get(LCats, field, &cat))
continue;
}
Vect_get_area_points(&In, area, LPoints);
write_line(&Out, LPoints, cat, vertex_type, flag.inter->answer,
dmax, driver, Fi);
nisles = Vect_get_area_num_isles(&In, area);
for (i = 0; i < nisles; i++) {
isle = Vect_get_area_isle(&In, area, i);
Vect_get_isle_points(&In, isle, LPoints);
write_line(&Out, LPoints, cat, vertex_type,
flag.inter->answer, dmax, driver, Fi);
}
}
}
if (!flag.table->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_build(&Out);
/* Free, close ... */
Vect_close(&In);
G_done_msg(_("%d points written to output vector map."),
Vect_get_num_primitives(&Out, GV_POINT));
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
/*!
\brief Copy a map including attribute tables
Old vector is deleted
\param in input vector map name
\param mapset mapset name
\param out output vector map name
\return -1 error
\return 0 success
*/
int Vect_copy(const char *in, const char *mapset, const char *out)
{
int i, n, ret, type;
struct Map_info In, Out;
struct field_info *Fi, *Fin;
char old_path[GPATH_MAX], new_path[GPATH_MAX], buf[GPATH_MAX];
const char *files[] = { GV_FRMT_ELEMENT, GV_COOR_ELEMENT,
GV_HEAD_ELEMENT, GV_HIST_ELEMENT,
GV_TOPO_ELEMENT, GV_SIDX_ELEMENT, GV_CIDX_ELEMENT,
NULL
};
const char *inmapset;
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
dbDriver *driver;
G_debug(2, "Copy vector '%s' in '%s' to '%s'", in, mapset, out);
/* check for [A-Za-z][A-Za-z0-9_]* in name */
if (Vect_legal_filename(out) < 0)
G_fatal_error(_("Vector map name is not SQL compliant"));
inmapset = G_find_vector2(in, mapset);
if (!inmapset) {
G_warning(_("Unable to find vector map <%s> in <%s>"), in, mapset);
return -1;
}
mapset = inmapset;
/* remove mapset from fully qualified name, confuses G_file_name() */
if (G_name_is_fully_qualified(in, xname, xmapset)) {
in = xname;
}
/* Delete old vector if it exists */
if (G_find_vector2(out, G_mapset())) {
G_warning(_("Vector map <%s> already exists and will be overwritten"),
out);
ret = Vect_delete(out);
if (ret != 0) {
G_warning(_("Unable to delete vector map <%s>"), out);
return -1;
}
}
/* Copy the directory */
G__make_mapset_element(GV_DIRECTORY);
sprintf(buf, "%s/%s", GV_DIRECTORY, out);
G__make_mapset_element(buf);
i = 0;
while (files[i]) {
sprintf(buf, "%s/%s", in, files[i]);
G_file_name(old_path, GV_DIRECTORY, buf, mapset);
sprintf(buf, "%s/%s", out, files[i]);
G_file_name(new_path, GV_DIRECTORY, buf, G_mapset());
if (access(old_path, F_OK) == 0) { /* file exists? */
G_debug(2, "copy %s to %s", old_path, new_path);
if (copy_file(old_path, new_path)) {
G_warning(_("Unable to copy vector map <%s> to <%s>"),
old_path, new_path);
}
}
i++;
}
G_file_name(old_path, GV_DIRECTORY, in, mapset);
G_file_name(new_path, GV_DIRECTORY, out, G_mapset());
/* Open input */
Vect_set_open_level(1);
Vect_open_old_head(&In, in, mapset);
if (In.format != GV_FORMAT_NATIVE) { /* Done */
Vect_close(&In);
return 0;
}
/* Open output */
Vect_set_open_level(1);
Vect_open_update_head(&Out, out, G_mapset());
/* Copy tables */
n = Vect_get_num_dblinks(&In);
type = GV_1TABLE;
if (n > 1)
type = GV_MTABLE;
for (i = 0; i < n; i++) {
Fi = Vect_get_dblink(&In, i);
if (Fi == NULL) {
G_warning(_("Database connection not defined for layer %d"),
In.dblnk->field[i].number);
Vect_close(&In);
Vect_close(&Out);
return -1;
}
Fin = Vect_default_field_info(&Out, Fi->number, Fi->name, type);
G_debug(3, "Copy drv:db:table '%s:%s:%s' to '%s:%s:%s'",
Fi->driver, Fi->database, Fi->table, Fin->driver,
Fin->database, Fin->table);
Vect_map_add_dblink(&Out, Fi->number, Fi->name, Fin->table, Fi->key,
Fin->database, Fin->driver);
ret = db_copy_table(Fi->driver, Fi->database, Fi->table,
Fin->driver, Vect_subst_var(Fin->database, &Out),
Fin->table);
if (ret == DB_FAILED) {
G_warning(_("Unable to copy table <%s>"), Fin->table);
Vect_close(&In);
Vect_close(&Out);
return -1;
}
driver =
db_start_driver_open_database(Fin->driver,
Vect_subst_var(Fin->database,
&Out));
if (driver == NULL) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fin->database, Fin->driver);
}
else {
if (db_create_index2(driver, Fin->table, Fi->key) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, Fi->key);
db_close_database_shutdown_driver(driver);
}
}
Vect_close(&In);
Vect_close(&Out);
return 0;
}
int main(int argc, char **argv)
{
int field, type, vertex_type;
double dmax;
struct Option *in_opt, *out_opt, *type_opt, *dmax_opt, *lfield_opt;
struct Flag *inter_flag, *vertex_flag, *table_flag, *node_flag;
struct GModule *module;
char *mapset;
struct Map_info In, Out;
struct line_cats *LCats;
struct line_pnts *LPoints;
char buf[2000];
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, geometry");
module->description =
_("Create points along input lines in new vector with 2 layers.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description = _("Input vector map containing lines");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->description =
_("Output vector map where points will be written");
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->answer = "point,line,boundary,centroid";
lfield_opt = G_define_standard_option(G_OPT_V_FIELD);
lfield_opt->key = "llayer";
lfield_opt->answer = "1";
lfield_opt->description = "Line layer";
node_flag = G_define_flag();
node_flag->key = 'n';
node_flag->description = _("Write line nodes");
vertex_flag = G_define_flag();
vertex_flag->key = 'v';
vertex_flag->description = _("Write line vertices");
inter_flag = G_define_flag();
inter_flag->key = 'i';
inter_flag->description = _("Interpolate points between line vertices");
dmax_opt = G_define_option();
dmax_opt->key = "dmax";
dmax_opt->type = TYPE_DOUBLE;
dmax_opt->required = NO;
dmax_opt->answer = "100";
dmax_opt->description = _("Maximum distance between points in map units");
table_flag = G_define_flag();
table_flag->key = 't';
table_flag->description = _("Do not create attribute table");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
LCats = Vect_new_cats_struct();
PCats = Vect_new_cats_struct();
LPoints = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
db_init_string(&stmt);
field = atoi(lfield_opt->answer);
type = Vect_option_to_types(type_opt);
dmax = atof(dmax_opt->answer);
if (node_flag->answer && vertex_flag->answer)
G_fatal_error(_("Use either -n or -v flag, not both"));
if (node_flag->answer)
vertex_type = GV_NODE;
else if (vertex_flag->answer)
vertex_type = GV_VERTEX;
else
vertex_type = 0;
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
GV_FATAL_EXIT);
/* Open input lines */
mapset = G_find_vector2(in_opt->answer, NULL);
if (mapset == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(2);
Vect_open_old(&In, in_opt->answer, mapset);
/* Open output segments */
Vect_open_new(&Out, out_opt->answer, Vect_is_3d(&In));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Table */
if (!table_flag->answer) {
struct field_info *Fin;
/* copy input table */
Fin = Vect_get_field(&In, field);
if (Fin) { /* table defined */
int ret;
Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key,
Fi->database, Fi->driver);
ret = db_copy_table(Fin->driver, Fin->database, Fin->table,
Fi->driver, Vect_subst_var(Fi->database,
&Out), Fi->table);
if (ret == DB_FAILED) {
G_fatal_error(_("Unable to copy table <%s>"),
Fin->table);
}
}
Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 2, NULL, Fi->table, "cat", Fi->database,
Fi->driver);
/* Open driver */
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
sprintf(buf,
"create table %s ( cat int, lcat int, along double precision )",
Fi->table);
db_append_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
}
if (db_create_index2(driver, Fi->table, "cat") != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, "cat");
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
point_cat = 1;
if (type & (GV_POINTS | GV_LINES)) {
int line, nlines;
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype, cat;
G_debug(3, "line = %d", line);
ltype = Vect_read_line(&In, LPoints, LCats, line);
if (!(ltype & type))
continue;
Vect_cat_get(LCats, field, &cat);
if (LPoints->n_points <= 1) {
write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0],
cat, 0.0, table_flag->answer);
}
else { /* lines */
write_line(&Out, LPoints, cat, vertex_type,
inter_flag->answer, dmax, table_flag->answer);
}
G_percent(line, nlines, 2);
}
}
if (type == GV_AREA) {
int area, nareas, centroid, cat;
nareas = Vect_get_num_areas(&In);
for (area = 1; area <= nareas; area++) {
int i, isle, nisles;
centroid = Vect_get_area_centroid(&In, area);
cat = -1;
if (centroid > 0) {
Vect_read_line(&In, NULL, LCats, centroid);
Vect_cat_get(LCats, field, &cat);
}
Vect_get_area_points(&In, area, LPoints);
write_line(&Out, LPoints, cat, vertex_type, inter_flag->answer,
dmax, table_flag->answer);
nisles = Vect_get_area_num_isles(&In, area);
for (i = 0; i < nisles; i++) {
isle = Vect_get_area_isle(&In, area, i);
Vect_get_isle_points(&In, isle, LPoints);
write_line(&Out, LPoints, cat, vertex_type,
inter_flag->answer, dmax, table_flag->answer);
}
G_percent(area, nareas, 2);
}
}
if (!table_flag->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_build(&Out);
/* Free, close ... */
Vect_close(&In);
Vect_close(&Out);
G_done_msg(_("%d points written to output vector map"), point_cat - 1);
exit(EXIT_SUCCESS);
}