/**
\brief Select features by coordinates
\param[in] Map vector map
\param[in] type feature type
\param[in] coords coordinates GRASS parameters
\param[in] thresh threshold value for searching
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_coordinates(struct Map_info *Map,
int type, struct line_pnts *coords, double thresh,
struct ilist *List)
{
int i;
double east, north, maxdist;
struct ilist *List_tmp, *List_in_box;
struct line_pnts *box;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
box = Vect_new_line_struct();
List_in_box = Vect_new_list();
if (thresh < 0)
maxdist = max_distance(thresh);
else
maxdist = thresh;
for (i = 0; i < coords->n_points; i++) {
east = coords->x[i];
north = coords->y[i];
coord2bbox(east, north, maxdist, box);
Vect_select_lines_by_polygon(Map, box, 0, NULL, type, List_in_box);
if (List_in_box->n_values > 0)
Vect_list_append_list(List_tmp, List_in_box);
}
G_debug(1, " %d lines selected (by coordinates)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
Vect_destroy_line_struct(box);
Vect_destroy_list(List_in_box);
return List->n_values;
}
QgsGrassFeatureIterator::QgsGrassFeatureIterator( QgsGrassProvider* p, const QgsFeatureRequest& request )
: QgsAbstractFeatureIterator( request ), P( p )
{
// make sure that only one iterator is active
if ( P->mActiveIterator )
{
QgsMessageLog::logMessage( QObject::tr( "Already active iterator on this provider was closed." ), QObject::tr( "GRASS" ) );
P->mActiveIterator->close();
}
P->mActiveIterator = this;
// check if outdated and update if necessary
P->ensureUpdated();
// Init structures
mPoints = Vect_new_line_struct();
mCats = Vect_new_cats_struct();
mList = Vect_new_list();
// Create selection array
allocateSelection( P->mMap );
resetSelection( 1 );
if ( request.filterType() == QgsFeatureRequest::FilterRect )
{
setSelectionRect( request.filterRect(), request.flags() & QgsFeatureRequest::ExactIntersect );
}
else
{
// TODO: implement fast lookup by feature id
//no filter - use all features
resetSelection( 1 );
}
}
/**
\brief Reverse list selection
\param[in] Map vector map
\param[in] type feature type
\param[in,out] reversed list
\return 1
*/
int reverse_selection(struct Map_info *Map, int type, struct ilist **List)
{
struct ilist *list_reverse;
int line, nlines, ltype;
list_reverse = Vect_new_list();
nlines = Vect_get_num_lines(Map);
for (line = 1; line <= nlines; line++) {
ltype = Vect_read_line(Map, NULL, NULL, line);
if (!(ltype & type))
continue;
if (!Vect_val_in_list(*List, line))
Vect_list_append(list_reverse, line);
}
Vect_destroy_list(*List);
*List = list_reverse;
return 1;
}
QgsGrassFeatureIterator::QgsGrassFeatureIterator( QgsGrassFeatureSource* source, bool ownSource, const QgsFeatureRequest& request )
: QgsAbstractFeatureIteratorFromSource<QgsGrassFeatureSource>( source, ownSource, request )
{
sMutex.lock();
// Init structures
mPoints = Vect_new_line_struct();
mCats = Vect_new_cats_struct();
mList = Vect_new_list();
// Create selection array
allocateSelection( mSource->mMap );
resetSelection( 1 );
if ( request.filterType() == QgsFeatureRequest::FilterRect )
{
setSelectionRect( request.filterRect(), request.flags() & QgsFeatureRequest::ExactIntersect );
}
else
{
// TODO: implement fast lookup by feature id
//no filter - use all features
resetSelection( 1 );
}
}
/**
\brief Select features by polygon
\param[in] Map vector map
\param[in] type feature type
\param[in] poly polygon coordinates
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_polygon(struct Map_info *Map,
int type, struct line_pnts *Polygon, struct ilist *List)
{
struct ilist *List_tmp;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
/* no isles */
Vect_select_lines_by_polygon(Map, Polygon, 0, NULL, type, List_tmp);
G_debug(1, " %d lines selected (by polygon)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
return List->n_values;
}
/**
\brief Select features by category
\param[in] Map vector map
\param[in] cl_orig original list of categories (previously selected)
\param[in] layer layer number
\param[in] type feature type
\param[in] cat category string
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_cat(struct Map_info *Map, struct cat_list *cl_orig,
int layer, int type, char *cats, struct ilist *List)
{
struct ilist *List_tmp, *List_tmp1;
struct cat_list *cl;
int i, cat;
if (first_selection || cl_orig) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
List_tmp1 = Vect_new_list();
if (cl_orig == NULL) {
cl = Vect_new_cat_list();
Vect_str_to_cat_list(cats, cl);
}
else {
cl = cl_orig;
}
for (i = 0; i < cl->n_ranges; i++) {
for (cat = cl->min[i]; cat <= cl->max[i]; cat++) {
Vect_cidx_find_all(Map, layer, type, cat, List_tmp1);
Vect_list_append_list(List_tmp, List_tmp1);
}
}
G_debug(1, " %d lines selected (by category)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
Vect_destroy_list(List_tmp1);
return List->n_values;
}
int point_in_buffer(struct buf_contours *arr_bc, struct spatial_index *si,
struct Map_info *Buf, double x, double y)
{
int i, j, ret, flag;
struct bound_box bbox;
static struct ilist *List = NULL;
static struct line_pnts *Points = NULL;
if (List == NULL)
List = Vect_new_list();
if (Points == NULL)
Points = Vect_new_line_struct();
/* select outer contours overlapping with centroid (x, y) */
bbox.W = bbox.E = x;
bbox.N = bbox.S = y;
bbox.T = PORT_DOUBLE_MAX;
bbox.B = -PORT_DOUBLE_MAX;
Vect_spatial_index_select(si, &bbox, List);
for (i = 0; i < List->n_values; i++) {
Vect_read_line(Buf, Points, NULL, arr_bc[List->value[i]].outer);
ret = Vect_point_in_poly(x, y, Points);
if (ret == 0)
continue;
flag = 1;
for (j = 0; j < arr_bc[List->value[i]].inner_count; j++) {
if (arr_bc[List->value[i]].inner[j] < 1)
continue;
Vect_read_line(Buf, Points, NULL, arr_bc[List->value[i]].inner[j]);
ret = Vect_point_in_poly(x, y, Points);
if (ret != 0) { /* inside inner contour */
flag = 0;
break;
}
}
if (flag) {
/* (x,y) is inside outer contour and outside inner contours of arr_bc[i] */
return 1;
}
}
return 0;
}
/**
\brief Select features by id
\param[in] Map vector map
\param[in] type feature type
\param[in] ids ids list
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_id(struct Map_info *Map, int type, char *ids, struct ilist *List)
{
int i;
int num, id;
struct cat_list *il; /* NOTE: this is not cat list, but list of id's */
struct ilist *List_tmp;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
il = Vect_new_cat_list();
Vect_str_to_cat_list(ids, il);
num = Vect_get_num_lines(Map);
for (i = 0; i < il->n_ranges; i++) {
for (id = 1; id <= num; id++) {
if (!(Vect_read_line(Map, NULL, NULL, id) & type)) {
continue;
}
if (id >= il->min[i] && id <= il->max[i]) {
Vect_list_append(List_tmp, id);
}
}
}
G_debug(1, " %d lines selected (by id)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
Vect_destroy_cat_list(il);
return List->n_values;
}
/**
\brief merge two list, i.e. store only duplicate items
\param[in] alist,blist list to be merged
\return result number of items
*/
static int merge_lists(struct ilist *alist, struct ilist *blist)
{
int i;
struct ilist *list_del;
list_del = Vect_new_list();
for (i = 0; i < alist->n_values; i++) {
if (!Vect_val_in_list(blist, alist->value[i]))
Vect_list_append(list_del, alist->value[i]);
}
Vect_list_delete_list(alist, list_del);
Vect_destroy_list(list_del);
return alist->n_values;
}
int find_node(struct Map_info *Pnts, int field, int cat)
{
static struct ilist *list;
if (!list)
list = Vect_new_list();
/* find start node */
Vect_cidx_find_all(Pnts, field, GV_POINT, cat, list);
if (list->n_values < 1) {
G_warning(_("No point with category %d found"), cat);
return 0;
}
if (list->n_values > 1) {
G_warning(_("More points with category %d found"), cat);
return 0;
}
return list->value[0];
}
/**
\brief Select features by bbox
\param[in] Map vector map
\param[in] type feature type
\param[in] bbox_opt bounding boxes
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_bbox(struct Map_info *Map,
int type, double x1, double y1, double x2, double y2,
struct ilist *List)
{
BOUND_BOX bbox;
struct ilist *List_tmp;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
/* bounding box */
bbox.N = y1 < y2 ? y2 : y1;
bbox.S = y1 < y2 ? y1 : y2;
bbox.W = x1 < x2 ? x1 : x2;
bbox.E = x1 < x2 ? x2 : x1;
bbox.T = PORT_DOUBLE_MAX;
bbox.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(Map, &bbox, type, List_tmp);
G_debug(1, " %d lines selected (by bbox)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
return List->n_values;
}
/* Calculate costs for MST on given set of terminals.
* If AList / NList is not NULL, list of arcs / nodes in MST is created
* Note: qsort() from more (say >30) terminals, takes long time (most of mst()).
* To improve the speed, there are used two sorted queues of costs:
* 1. for all combinations of in trms
* 2. from 'sp' to all other terminals
* Because 1. is sorted only if new sp as added to list of terminals,
* and 2. is much shorter than 1., a lot of time is saved.
*/
int mst(struct Map_info *Map, int *trms, int ntrms, /* array of terminal, number of terminals */
double *cst, double max_cst, /* cost, maximum cost */
struct ilist *AList, struct ilist *NList, /* list of arcs/nodes in ST */
int sp, /* Steiner point (node) to be tested with terminals, (0 = ignore) */
int rebuild)
{ /* rebuild the sorted list of costs for terminals */
int i, j, node1, node2, com1, com2, t1, t2, line;
static int k;
int tcpos, scpos; /* current position in the term_costs / sp_costs */
double tcst;
struct ilist *List;
int nsteps, quse;
int nall; /* number of terminals + sp ( if used ) */
if (AList != NULL) {
Vect_reset_list(AList);
}
List = Vect_new_list();
/* Create sorted array for all combinations of terms */
if (rebuild) {
k = 0;
for (i = 0; i < ntrms; i++) {
for (j = i + 1; j < ntrms; j++) {
term_costs[k].term1 = i;
term_costs[k].term2 = j;
get_node_costs(trms[i], trms[j], &tcst);
term_costs[k].cost = tcst;
k++;
}
}
qsort((void *)term_costs, k, sizeof(COST), cmp); /* this takes most of a time in mst() */
for (i = 0; i < k; i++) {
G_debug(3, " %d - %d cost = %f\n", term_costs[i].term1,
term_costs[i].term2, term_costs[i].cost);
}
}
/* Create sorted array for all combinations of sp -> terms */
if (sp > 0) {
for (i = 0; i < ntrms; i++) {
sp_costs[i].term1 = -1; /* not needed */
sp_costs[i].term2 = i;
get_node_costs(sp, trms[i], &tcst);
sp_costs[i].cost = tcst;
}
qsort((void *)sp_costs, ntrms, sizeof(COST), cmp);
for (i = 0; i < ntrms; i++) {
G_debug(3, " %d - %d cost = %f\n", sp_costs[i].term1,
sp_costs[i].term2, sp_costs[i].cost);
}
}
tcst = 0;
/* MST has number_of_terminals-1 arcs */
if (sp > 0) {
nall = ntrms + 1;
nsteps = ntrms; /* i.e. + one StP */
}
else {
nall = ntrms;
nsteps = ntrms - 1;
}
G_debug(1, "nall = %d\n", nall);
for (i = 0; i < nall; i++)
comps[i] = 0;
tcpos = 0;
scpos = 0;
G_debug(2, "nsteps = %d\n", nsteps);
for (i = 0; i < nsteps; i++) {
G_debug(2, "step = %d\n", i);
/* Take the best (lowest costs, no cycle) from both queues */
/* For both queues go to next lowest costs without cycle */
/* treminal costs */
for (j = tcpos; j < k; j++) {
t1 = term_costs[j].term1;
t2 = term_costs[j].term2;
com1 = comps[t1];
com2 = comps[t2];
if (com1 != com2 || com1 == 0) { /* will not create cycle -> candidate */
tcpos = j;
break;
}
}
if (j == k) { /* arc without cycle not found */
tcpos = -1;
}
/* StP costs */
if (sp > 0) {
for (j = scpos; j < ntrms; j++) {
t1 = ntrms; /* StP is on first fre position */
t2 = sp_costs[j].term2;
com1 = comps[t1];
com2 = comps[t2];
G_debug(3, "scpos: j = %d comps(%d) = %d coms(%d) = %d\n", j,
t1, com1, t2, com2);
if (com1 != com2 || com1 == 0) { /* will not create cycle -> candidate */
scpos = j;
G_debug(3, " ok -> scpos = %d\n", scpos);
break;
}
}
if (j == ntrms) { /* arc without cycle not found */
scpos = -1;
}
}
else {
scpos = -1;
}
/* Do not access invalid items even for debugging */
if (tcpos != -1 && scpos != -1)
G_debug(3, "tcost = %f, scost = %f\n", term_costs[tcpos].cost,
sp_costs[scpos].cost);
/* Now we have positions set on lowest costs in each queue or -1 if no more/not used */
if (tcpos >= 0 && scpos >= 0) {
if (term_costs[tcpos].cost < sp_costs[scpos].cost)
quse = 1; /* use terms queue */
else
quse = 2; /* use sp queue */
}
else if (tcpos >= 0) {
quse = 1; /* use terms queue */
}
else {
quse = 2; /* use sp queue */
}
/* Now we know from which queue take next arc -> add arc to components */
if (quse == 1) {
t1 = term_costs[tcpos].term1;
t2 = term_costs[tcpos].term2;
tcst += term_costs[tcpos].cost;
tcpos++;
}
else {
t1 = ntrms;
t2 = sp_costs[scpos].term2;
tcst += sp_costs[scpos].cost;
scpos++;
}
G_debug(3, "quse = %d t1 = %d t2 = %d\n", quse, t1, t2);
G_debug(3, "tcst = %f (max = %f)\n", tcst, max_cst);
com1 = comps[t1];
com2 = comps[t2];
comps[t1] = i + 1;
comps[t2] = i + 1;
G_debug(3, "comps(%d) = %d coms(%d) = %d\n", t1, i + 1, t2, i + 1);
/* reset connected branches */
for (j = 0; j < nall; j++) {
if (comps[j] == com1 && com1 != 0)
comps[j] = i + 1;
if (comps[j] == com2 && com2 != 0)
comps[j] = i + 1;
}
if (tcst > max_cst) {
G_debug(3, "cost > max -> return\n");
*cst = PORT_DOUBLE_MAX;
return 1;
}
/* add to list of arcs */
if (AList != NULL) {
node1 = trms[t1];
node2 = trms[t2];
Vect_net_shortest_path(Map, node1, node2, List, NULL);
for (j = 0; j < List->n_values; j++) {
Vect_list_append(AList, abs(List->value[j]));
}
}
}
/* create list of nodes */
if (NList != NULL) {
Vect_reset_list(NList);
for (i = 0; i < AList->n_values; i++) {
line = AList->value[i];
Vect_get_line_nodes(Map, line, &node1, &node2);
Vect_list_append(NList, node1);
Vect_list_append(NList, node2);
}
}
*cst = tcst;
Vect_destroy_list(List);
return 1;
}
int main(int argc, char *argv[])
{
int out_fd;
CELL *result, *rp;
int nrows, ncols;
int row, col;
struct GModule *module;
struct Option *in_opt, *out_opt;
struct Option *method_opt, *size_opt;
char *mapset;
struct Map_info In;
double radius;
struct ilist *List;
struct Cell_head region;
BOUND_BOX box;
struct line_pnts *Points;
struct line_cats *Cats;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, raster, aggregation");
module->description = "Makes each cell value a "
"function of the attribute values assigned to the vector points or centroids "
"around it, and stores new cell values in an output raster map layer.";
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_R_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->options = "count";
method_opt->answer = "count";
method_opt->description = "Neighborhood operation";
size_opt = G_define_option();
size_opt->key = "size";
size_opt->type = TYPE_DOUBLE;
size_opt->required = YES;
size_opt->description = "Neighborhood diameter in map units";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
radius = atof(size_opt->answer) / 2;
/* open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found in the current mapset"),
in_opt->answer);
}
Vect_set_open_level(2);
Vect_open_old(&In, in_opt->answer, mapset);
G_get_set_window(®ion);
nrows = G_window_rows();
ncols = G_window_cols();
result = G_allocate_raster_buf(CELL_TYPE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_list();
/*open the new cellfile */
out_fd = G_open_raster_new(out_opt->answer, CELL_TYPE);
if (out_fd < 0)
G_fatal_error(_("Unable to create raster map <%s>"), out_opt->answer);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
for (row = 0; row < nrows; row++) {
double x, y;
G_percent(row, nrows, 1);
y = G_row_to_northing(row + 0.5, ®ion);
box.N = y + radius;
box.S = y - radius;
G_set_null_value(result, ncols, CELL_TYPE);
rp = result;
for (col = 0; col < ncols; col++) {
int i, count;
CELL value;
x = G_col_to_easting(col + 0.5, ®ion);
box.E = x + radius;
box.W = x - radius;
Vect_select_lines_by_box(&In, &box, GV_POINTS, List);
G_debug(3, " %d lines in box", List->n_values);
count = 0;
for (i = 0; i < List->n_values; i++) {
double distance;
Vect_read_line(&In, Points, Cats, List->value[i]);
distance =
Vect_points_distance(x, y, 0.0, Points->x[0],
Points->y[0], 0.0, 0);
if (distance <= radius) {
count++;
}
}
if (count > 0) {
value = count;
G_set_raster_value_d(rp, value, CELL_TYPE);
}
rp = G_incr_void_ptr(rp, G_raster_size(CELL_TYPE));
}
G_put_raster_row(out_fd, result, CELL_TYPE);
}
G_percent(row, nrows, 1);
Vect_close(&In);
G_close_cell(out_fd);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *map_opt, *field_opt, *fs_opt, *vs_opt, *nv_opt, *col_opt,
*where_opt, *file_opt;
struct Flag *c_flag, *v_flag, *r_flag;
dbDriver *driver;
dbString sql, value_string;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
struct field_info *Fi;
int ncols, col, more;
struct Map_info Map;
char query[1024];
struct ilist *list_lines;
struct bound_box *min_box, *line_box;
int i, line, area, init_box, cat;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
module->description = _("Prints vector map attributes.");
map_opt = G_define_standard_option(G_OPT_V_MAP);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
col_opt = G_define_standard_option(G_OPT_DB_COLUMNS);
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
fs_opt = G_define_standard_option(G_OPT_F_SEP);
fs_opt->description = _("Output field separator");
fs_opt->guisection = _("Format");
vs_opt = G_define_standard_option(G_OPT_F_SEP);
vs_opt->key = "vs";
vs_opt->description = _("Output vertical record separator");
vs_opt->answer = NULL;
vs_opt->guisection = _("Format");
nv_opt = G_define_option();
nv_opt->key = "nv";
nv_opt->type = TYPE_STRING;
nv_opt->required = NO;
nv_opt->description = _("Null value indicator");
nv_opt->guisection = _("Format");
file_opt = G_define_standard_option(G_OPT_F_OUTPUT);
file_opt->key = "file";
file_opt->required = NO;
file_opt->description =
_("Name for output file (if omitted or \"-\" output to stdout)");
r_flag = G_define_flag();
r_flag->key = 'r';
r_flag->description =
_("Print minimal region extent of selected vector features instead of attributes");
c_flag = G_define_flag();
c_flag->key = 'c';
c_flag->description = _("Do not include column names in output");
c_flag->guisection = _("Format");
v_flag = G_define_flag();
v_flag->key = 'v';
v_flag->description = _("Vertical output (instead of horizontal)");
v_flag->guisection = _("Format");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* set input vector map name and mapset */
if (file_opt->answer && strcmp(file_opt->answer, "-") != 0) {
if (NULL == freopen(file_opt->answer, "w", stdout)) {
G_fatal_error(_("Unable to open file <%s> for writing"), file_opt->answer);
}
}
if (r_flag->answer) {
min_box = (struct bound_box *) G_malloc(sizeof(struct bound_box));
G_zero((void *)min_box, sizeof(struct bound_box));
line_box = (struct bound_box *) G_malloc(sizeof(struct bound_box));
list_lines = Vect_new_list();
}
else {
min_box = line_box = NULL;
list_lines = NULL;
}
db_init_string(&sql);
db_init_string(&value_string);
/* open input vector */
if (!r_flag->answer)
Vect_open_old_head2(&Map, map_opt->answer, "", field_opt->answer);
else {
if (2 > Vect_open_old2(&Map, map_opt->answer, "", field_opt->answer)) {
Vect_close(&Map);
G_fatal_error(_("Unable to open vector map <%s> at topology level. "
"Flag '%c' requires topology level."),
map_opt->answer, r_flag->key);
}
}
if ((Fi = Vect_get_field2(&Map, field_opt->answer)) == NULL)
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_opt->answer);
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
if (col_opt->answer)
sprintf(query, "SELECT %s FROM ", col_opt->answer);
else
sprintf(query, "SELECT * FROM ");
db_set_string(&sql, query);
db_append_string(&sql, Fi->table);
if (where_opt->answer) {
char *buf = NULL;
buf = G_malloc((strlen(where_opt->answer) + 8));
sprintf(buf, " WHERE %s", where_opt->answer);
db_append_string(&sql, buf);
G_free(buf);
}
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open select cursor"));
table = db_get_cursor_table(&cursor);
ncols = db_get_table_number_of_columns(table);
/* column names if horizontal output (ignore for -r) */
if (!v_flag->answer && !c_flag->answer && !r_flag->answer) {
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
if (col)
fprintf(stdout, "%s", fs_opt->answer);
fprintf(stdout, "%s", db_get_column_name(column));
}
fprintf(stdout, "\n");
}
init_box = 1;
/* fetch the data */
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
G_fatal_error(_("Unable to fetch data from table <%s>"),
Fi->table);
if (!more)
break;
cat = -1;
for (col = 0; col < ncols; col++) {
column = db_get_table_column(table, col);
value = db_get_column_value(column);
if (cat < 0 && strcmp(Fi->key, db_get_column_name(column)) == 0) {
cat = db_get_value_int(value);
if (r_flag->answer)
break;
}
if (r_flag->answer)
continue;
db_convert_column_value_to_string(column, &value_string);
if (!c_flag->answer && v_flag->answer)
fprintf(stdout, "%s%s", db_get_column_name(column),
fs_opt->answer);
if (col && !v_flag->answer)
fprintf(stdout, "%s", fs_opt->answer);
if (nv_opt->answer && db_test_value_isnull(value))
fprintf(stdout, "%s", nv_opt->answer);
else
fprintf(stdout, "%s", db_get_string(&value_string));
if (v_flag->answer)
fprintf(stdout, "\n");
}
if (r_flag->answer) {
/* get minimal region extent */
Vect_cidx_find_all(&Map, Vect_get_field_number(&Map, field_opt->answer), -1, cat, list_lines);
for (i = 0; i < list_lines->n_values; i++) {
line = list_lines->value[i];
area = Vect_get_centroid_area(&Map, line);
if (area > 0) {
if (!Vect_get_area_box(&Map, area, line_box))
G_fatal_error(_("Unable to get bounding box of area %d"),
area);
}
else {
if (!Vect_get_line_box(&Map, line, line_box))
G_fatal_error(_("Unable to get bounding box of line %d"),
line);
}
if (init_box) {
Vect_box_copy(min_box, line_box);
init_box = 0;
}
else {
Vect_box_extend(min_box, line_box);
}
}
}
else {
if (!v_flag->answer)
fprintf(stdout, "\n");
else if (vs_opt->answer)
fprintf(stdout, "%s\n", vs_opt->answer);
}
}
if (r_flag->answer) {
fprintf(stdout, "n=%f\n", min_box->N);
fprintf(stdout, "s=%f\n", min_box->S);
fprintf(stdout, "w=%f\n", min_box->W);
fprintf(stdout, "e=%f\n", min_box->E);
if (Vect_is_3d(&Map)) {
fprintf(stdout, "t=%f\n", min_box->T);
fprintf(stdout, "b=%f\n", min_box->B);
}
fflush(stdout);
G_free((void *)min_box);
G_free((void *)line_box);
Vect_destroy_list(list_lines);
}
db_close_cursor(&cursor);
db_close_database_shutdown_driver(driver);
Vect_close(&Map);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int i, j, k, ret;
int nlines, type, ltype, afield, tfield, geo, cat;
int sp, nsp, nspused, node, line;
struct Option *map, *output, *afield_opt, *tfield_opt, *afcol, *type_opt,
*term_opt, *nsp_opt;
struct Flag *geo_f;
struct GModule *module;
struct Map_info Map, Out;
int *testnode; /* array all nodes: 1 - should be tested as Steiner,
* 0 - no need to test (unreachable or terminal) */
struct ilist *TList; /* list of terminal nodes */
struct ilist *StArcs; /* list of arcs on Steiner tree */
struct ilist *StNodes; /* list of nodes on Steiner tree */
struct boxlist *pointlist;
double cost, tmpcost;
struct cat_list *Clist;
struct line_cats *Cats;
struct line_pnts *Points;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("steiner tree"));
module->label =
_("Creates Steiner tree for the network and given terminals.");
module->description =
_("Note that 'Minimum Steiner Tree' problem is NP-hard "
"and heuristic algorithm is used in this module so "
"the result may be sub optimal.");
map = G_define_standard_option(G_OPT_V_INPUT);
output = G_define_standard_option(G_OPT_V_OUTPUT);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->key = "arc_type";
type_opt->options = "line,boundary";
type_opt->answer = "line,boundary";
type_opt->label = _("Arc type");
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "arc_layer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
tfield_opt = G_define_standard_option(G_OPT_V_FIELD);
tfield_opt->key = "node_layer";
tfield_opt->answer = "2";
tfield_opt->label = _("Node layer (used for terminals)");
afcol = G_define_option();
afcol->key = "acolumn";
afcol->type = TYPE_STRING;
afcol->required = NO;
afcol->description = _("Arcs' cost column (for both directions)");
term_opt = G_define_standard_option(G_OPT_V_CATS);
term_opt->key = "terminal_cats";
term_opt->required = YES;
term_opt->description =
_("Categories of points on terminals (layer is specified by nlayer)");
nsp_opt = G_define_option();
nsp_opt->key = "npoints";
nsp_opt->type = TYPE_INTEGER;
nsp_opt->required = NO;
nsp_opt->multiple = NO;
nsp_opt->answer = "-1";
nsp_opt->description = _("Number of Steiner points (-1 for all possible)");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Cats = Vect_new_cats_struct();
Points = Vect_new_line_struct();
type = Vect_option_to_types(type_opt);
afield = atoi(afield_opt->answer);
TList = Vect_new_list();
StArcs = Vect_new_list();
StNodes = Vect_new_list();
Clist = Vect_new_cat_list();
tfield = atoi(tfield_opt->answer);
Vect_str_to_cat_list(term_opt->answer, Clist);
G_debug(1, "Imput categories:\n");
for (i = 0; i < Clist->n_ranges; i++) {
G_debug(1, "%d - %d\n", Clist->min[i], Clist->max[i]);
}
if (geo_f->answer)
geo = 1;
else
geo = 0;
Vect_check_input_output_name(map->answer, output->answer, G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old(&Map, map->answer, "") < 0)
G_fatal_error(_("Unable to open vector map <%s>"), map->answer);
nnodes = Vect_get_num_nodes(&Map);
nlines = Vect_get_num_lines(&Map);
/* Create list of terminals based on list of categories */
for (i = 1; i <= nlines; i++) {
ltype = Vect_get_line_type(&Map, i);
if (!(ltype & GV_POINT))
continue;
Vect_read_line(&Map, Points, Cats, i);
if (!(Vect_cat_get(Cats, tfield, &cat)))
continue;
node = Vect_find_node(&Map, Points->x[0], Points->y[0], Points->z[0], 0, 0);
if (!node) {
G_warning(_("Point is not connected to the network (cat=%d)"), cat);
continue;
}
if (Vect_cat_in_cat_list(cat, Clist)) {
Vect_list_append(TList, node);
}
}
nterms = TList->n_values;
/* GTC Terminal refers to an Steiner tree endpoint */
G_message(_("Number of terminals: %d\n"), nterms);
if (nterms < 2) {
/* GTC Terminal refers to an Steiner tree endpoint */
G_fatal_error(_("Not enough terminals (< 2)"));
}
/* Number of steiner points */
nsp = atoi(nsp_opt->answer);
if (nsp > nterms - 2) {
nsp = nterms - 2;
G_warning(_("Requested number of Steiner points > than possible"));
}
else if (nsp == -1) {
nsp = nterms - 2;
}
G_message(_("Number of Steiner points set to %d\n"), nsp);
testnode = (int *)G_malloc((nnodes + 1) * sizeof(int));
for (i = 1; i <= nnodes; i++)
testnode[i] = 1;
/* Alloc arrays of costs for nodes, first node at 1 (0 not used) */
nodes_costs = (double **)G_malloc((nnodes) * sizeof(double *));
for (i = 0; i < nnodes; i++) {
nodes_costs[i] =
(double *)G_malloc((nnodes - i) * sizeof(double));
for (j = 0; j < nnodes - i; j++)
nodes_costs[i][j] = -1; /* init, i.e. cost was not calculated yet */
}
/* alloc memory from each to each other (not directed) terminal */
i = nterms + nterms - 2; /* max number of terms + Steiner points */
comps = (int *)G_malloc(i * sizeof(int));
i = i * (i - 1) / 2; /* number of combinations */
term_costs = (COST *) G_malloc(i * sizeof(COST));
/* alloc memory for costs from Stp to each other terminal */
i = nterms + nterms - 2 - 1; /* max number of terms + Steiner points - 1 */
sp_costs = (COST *) G_malloc(i * sizeof(COST));
terms = (int *)G_malloc((nterms + nterms - 2) * sizeof(int)); /* i.e. +(nterms - 2) St Points */
/* Create initial parts from list of terminals */
G_debug(1, "List of terminal nodes (%d):\n", nterms);
for (i = 0; i < nterms; i++) {
G_debug(1, "%d\n", TList->value[i]);
terms[i] = TList->value[i];
testnode[terms[i]] = 0; /* do not test as Steiner */
}
/* Build graph */
Vect_net_build_graph(&Map, type, afield, 0, afcol->answer, NULL, NULL,
geo, 0);
/* Init costs for all terminals */
for (i = 0; i < nterms; i++)
init_node_costs(&Map, terms[i]);
/* Test if all terminal may be connected */
for (i = 1; i < nterms; i++) {
ret = get_node_costs(terms[0], terms[i], &cost);
if (ret == 0) {
/* GTC Terminal refers to an Steiner tree endpoint */
G_fatal_error(_("Terminal at node [%d] cannot be connected "
"to terminal at node [%d]"), terms[0], terms[i]);
}
}
/* Remove not reachable from list of SP candidates */
j = 0;
for (i = 1; i <= nnodes; i++) {
ret = get_node_costs(terms[0], i, &cost);
if (ret == 0) {
testnode[i] = 0;
G_debug(2, "node %d removed from list of Steiner point candidates\n", i );
j++;
}
}
G_message(_("[%d] (not reachable) nodes removed from list "
"of Steiner point candidates"), j);
/* calc costs for terminals MST */
ret = mst(&Map, terms, nterms, &cost, PORT_DOUBLE_MAX, NULL, NULL, 0, 1); /* no StP, rebuild */
G_message(_("MST costs = %f"), cost);
/* Go through all nodes and try to use as steiner points -> find that which saves most costs */
nspused = 0;
for (j = 0; j < nsp; j++) {
sp = 0;
G_verbose_message(_("Search for [%d]. Steiner point"), j + 1);
for (i = 1; i <= nnodes; i++) {
G_percent(i, nnodes, 1);
if (testnode[i] == 0) {
G_debug(3, "skip test for %d\n", i);
continue;
}
ret =
mst(&Map, terms, nterms + j, &tmpcost, cost, NULL, NULL, i,
0);
G_debug(2, "cost = %f x %f\n", tmpcost, cost);
if (tmpcost < cost) { /* sp candidate */
G_debug(3,
" steiner candidate node = %d mst = %f (x last = %f)\n",
i, tmpcost, cost);
sp = i;
cost = tmpcost;
}
}
if (sp > 0) {
G_message(_("Steiner point at node [%d] was added "
"to terminals (MST costs = %f)"), sp, cost);
terms[nterms + j] = sp;
init_node_costs(&Map, sp);
testnode[sp] = 0;
nspused++;
/* rebuild for nex cycle */
ret =
mst(&Map, terms, nterms + nspused, &tmpcost, PORT_DOUBLE_MAX,
NULL, NULL, 0, 1);
}
else { /* no steiner found */
G_message(_("No Steiner point found -> leaving cycle"));
break;
}
}
G_message(_("Number of added Steiner points: %d "
"(theoretic max is %d).\n"), nspused, nterms - 2);
/* Build lists of arcs and nodes for final version */
ret =
mst(&Map, terms, nterms + nspused, &cost, PORT_DOUBLE_MAX, StArcs,
StNodes, 0, 0);
/* Calculate true costs, which may be lower than MST if steiner points were not used */
if (nsp < nterms - 2) {
G_message(_("Spanning tree costs on complet graph = %f\n"
"(may be higher than resulting Steiner tree costs!!!)"),
cost);
}
else
G_message(_("Steiner tree costs = %f"), cost);
/* Write arcs to new map */
if (Vect_open_new(&Out, output->answer, Vect_is_3d(&Map)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
Vect_hist_command(&Out);
G_debug(1, "Steiner tree:");
G_debug(1, "Arcs' categories (layer %d, %d arcs):", afield,
StArcs->n_values);
for (i = 0; i < StArcs->n_values; i++) {
line = StArcs->value[i];
ltype = Vect_read_line(&Map, Points, Cats, line);
Vect_write_line(&Out, ltype, Points, Cats);
Vect_cat_get(Cats, afield, &cat);
G_debug(1, "arc cat = %d", cat);
}
G_debug(1, "Nodes' categories (layer %d, %d nodes):", tfield,
StNodes->n_values);
k = 0;
pointlist = Vect_new_boxlist(0);
for (i = 0; i < StNodes->n_values; i++) {
double x, y, z;
struct bound_box box;
node = StNodes->value[i];
Vect_get_node_coor(&Map, node, &x, &y, &z);
box.E = box.W = x;
box.N = box.S = y;
box.T = box.B = z;
Vect_select_lines_by_box(&Map, &box, GV_POINT, pointlist);
nlines = Vect_get_node_n_lines(&Map, node);
for (j = 0; j < pointlist->n_values; j++) {
line = pointlist->id[j];
ltype = Vect_read_line(&Map, Points, Cats, line);
if (!(ltype & GV_POINT))
continue;
if (!(Vect_cat_get(Cats, tfield, &cat)))
continue;
Vect_write_line(&Out, ltype, Points, Cats);
G_debug(1, "node cat = %d", cat);
k++;
}
}
Vect_build(&Out);
G_message(n_("A Steiner tree with %d arc has been built",
"A Steiner tree with %d arcs has been built", StArcs->n_values),
StArcs->n_values);
/* Free, ... */
Vect_destroy_list(StArcs);
Vect_destroy_list(StNodes);
Vect_close(&Map);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int export_areas_multi(struct Map_info *In, int field, int donocat,
OGRFeatureDefnH Ogr_featuredefn,OGRLayerH Ogr_layer,
struct field_info *Fi, dbDriver *driver, int ncol, int *colctype,
const char **colname, int doatt, int nocat,
int *n_noatt, int *n_nocat)
{
int i, n_exported, area;
int cat, ncats_field, line, type, findex, ipart;
struct line_pnts *Points;
struct line_cats *Cats;
struct ilist *cat_list, *line_list, *lcats;
OGRGeometryH Ogr_geometry, Ogr_geometry_part;
OGRFeatureH Ogr_feature;
OGRwkbGeometryType wkbtype, wkbtype_part;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
cat_list = Vect_new_list();
line_list = Vect_new_list();
lcats = Vect_new_list();
n_exported = 0;
/* check if category index is available for given field */
findex = Vect_cidx_get_field_index(In, field);
if (findex == -1)
G_fatal_error(_("Unable to export multi-features. No category index for layer %d."),
field);
/* determine type */
wkbtype_part = wkbPolygon;
wkbtype = get_multi_wkbtype(wkbtype_part);
ncats_field = Vect_cidx_get_unique_cats_by_index(In, findex, cat_list);
G_debug(1, "n_cats = %d for layer %d", ncats_field, field);
if (donocat)
G_message(_("Exporting features with category..."));
for (i = 0; i < cat_list->n_values; i++) {
G_percent(i, cat_list->n_values - 1, 5);
cat = cat_list->value[i];
/* find all centroids with given category */
Vect_cidx_find_all(In, field, GV_CENTROID, cat, line_list);
/* create multi-feature */
Ogr_geometry = OGR_G_CreateGeometry(wkbtype);
/* build simple features geometry, go through all parts */
for (ipart = 0; ipart < line_list->n_values; ipart++) {
line = line_list->value[ipart];
G_debug(3, "cat=%d, line=%d -> part=%d", cat, line, ipart);
/* get centroid's category */
Vect_read_line(In, NULL, Cats, line);
/* check for category consistency */
Vect_field_cat_get(Cats, field, lcats);
if (!Vect_val_in_list(lcats, cat))
G_fatal_error(_("Unable to create multi-feature. "
"Category %d not found in line %d, field %d"),
cat, line, field);
/* find correspoding area */
area = Vect_get_centroid_area(In, line);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry_part = create_polygon(In, area, Points);
/* add part */
OGR_G_AddGeometryDirectly(Ogr_geometry, Ogr_geometry_part);
}
if (!OGR_G_IsEmpty(Ogr_geometry)) {
/* write multi-feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
OGR_F_Destroy(Ogr_feature);
n_exported++;
}
else {
/* skip empty features */
G_debug(3, "multi-feature is empty -> skipped");
}
OGR_G_DestroyGeometry(Ogr_geometry);
}
if (donocat)
G_message(_("Exporting features without category..."));
/* check lines without category, if -c flag is given write them as
* one multi-feature */
Ogr_geometry = OGR_G_CreateGeometry(wkbtype);
Vect_rewind(In);
Vect_set_constraint_type(In, GV_CENTROID);
while(TRUE) {
type = Vect_read_next_line(In, NULL, Cats);
if (type < 0)
break;
/* get centroid's category */
Vect_cat_get(Cats, field, &cat);
if (cat > 0)
continue; /* skip features with category */
if (cat < 0 && !donocat) {
(*n_nocat)++;
continue; /* skip lines without category, do not export
* not labeled */
}
/* find correspoding area */
line = Vect_get_next_line_id(In);
area = Vect_get_centroid_area(In, line);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry_part = create_polygon(In, area, Points);
/* add part */
OGR_G_AddGeometryDirectly(Ogr_geometry, Ogr_geometry_part);
(*n_nocat)++;
}
if (!OGR_G_IsEmpty(Ogr_geometry)) {
/* write multi-feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
OGR_F_Destroy(Ogr_feature);
n_exported++;
}
else {
/* skip empty features */
G_debug(3, "multi-feature is empty -> skipped");
}
OGR_G_DestroyGeometry(Ogr_geometry);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
Vect_destroy_list(cat_list);
Vect_destroy_list(line_list);
Vect_destroy_list(lcats);
return n_exported;
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *afield_opt, *nfield_opt, *afcol, *ncol;
struct Flag *geo_f;
int with_z;
int afield, nfield, mask_type;
dglGraph_s *graph;
int i, edges, geo;
struct ilist *tree_list;
/* 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(_("network"));
G_add_keyword(_("spanning tree"));
module->description =
_("Computes minimum spanning tree for the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "alayer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "nlayer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "afcolumn";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
ncol = G_define_standard_option(G_OPT_DB_COLUMN);
ncol->key = "ncolumn";
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
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 (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
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 (geo_f->answer) {
geo = 1;
if (G_projection() != PROJECTION_LL)
G_warning(_("The current projection is not longitude-latitude"));
}
else
geo = 0;
/* parse filter option and select appropriate lines */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
if (0 != Vect_net_build_graph(&In, mask_type, afield, nfield, afcol->answer, NULL,
ncol->answer, geo, 0))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
tree_list = Vect_new_list();
edges = NetA_spanning_tree(graph, tree_list);
G_debug(3, "Edges: %d", edges);
for (i = 0; i < edges; i++) {
int type =
Vect_read_line(&In, Points, Cats, abs(tree_list->value[i]));
Vect_write_line(&Out, type, Points, Cats);
}
Vect_destroy_list(tree_list);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
void QgsGrassFeatureIterator::setSelectionRect( const QgsRectangle& rect, bool useIntersect )
{
QgsDebugMsg( QString( "useIntersect = %1 rect = %2" ).arg( useIntersect ).arg( rect.toString() ) );
// TODO: selection of edited lines
// Lock because functions using static/global variables are used
// (e.g. static LocList in Vect_select_lines_by_box, global BranchBuf in RTreeGetBranches)
QgsGrass::lock();
mSelection.fill( false );
BOUND_BOX box;
box.N = rect.yMaximum();
box.S = rect.yMinimum();
box.E = rect.xMaximum();
box.W = rect.xMinimum();
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
// Init structures
struct ilist * list = Vect_new_list();
if ( !useIntersect )
{ // select by bounding boxes only
if ( mSource->mLayerType == QgsGrassProvider::POINT || mSource->mLayerType == QgsGrassProvider::CENTROID ||
mSource->mLayerType == QgsGrassProvider::LINE || mSource->mLayerType == QgsGrassProvider::FACE ||
mSource->mLayerType == QgsGrassProvider::BOUNDARY ||
mSource->mLayerType == QgsGrassProvider::TOPO_POINT || mSource->mLayerType == QgsGrassProvider::TOPO_LINE ||
mSource->mEditing )
{
QgsDebugMsg( "Vect_select_lines_by_box" );
int type = mSource->mGrassType;
if ( mSource->mEditing )
{
type = GV_POINTS | GV_LINES;
}
QgsDebugMsg( QString( "type = %1" ).arg( type ) );
Vect_select_lines_by_box( mSource->map(), &box, type, list );
}
else if ( mSource->mLayerType == QgsGrassProvider::POLYGON )
{
Vect_select_areas_by_box( mSource->map(), &box, list );
}
else if ( mSource->mLayerType == QgsGrassProvider::TOPO_NODE )
{
Vect_select_nodes_by_box( mSource->map(), &box, list );
}
}
else
{ // check intersection
struct line_pnts *polygon = Vect_new_line_struct();
// Using z coor -PORT_DOUBLE_MAX/PORT_DOUBLE_MAX we cover 3D, Vect_select_lines_by_polygon is
// using dig_line_box to get the box, it is not perfect, Vect_select_lines_by_polygon
// should clarify better how 2D/3D is treated
Vect_append_point( polygon, rect.xMinimum(), rect.yMinimum(), -PORT_DOUBLE_MAX );
Vect_append_point( polygon, rect.xMaximum(), rect.yMinimum(), PORT_DOUBLE_MAX );
Vect_append_point( polygon, rect.xMaximum(), rect.yMaximum(), 0 );
Vect_append_point( polygon, rect.xMinimum(), rect.yMaximum(), 0 );
Vect_append_point( polygon, rect.xMinimum(), rect.yMinimum(), 0 );
if ( mSource->mLayerType == QgsGrassProvider::POINT || mSource->mLayerType == QgsGrassProvider::CENTROID ||
mSource->mLayerType == QgsGrassProvider::LINE || mSource->mLayerType == QgsGrassProvider::FACE ||
mSource->mLayerType == QgsGrassProvider::BOUNDARY ||
mSource->mLayerType == QgsGrassProvider::TOPO_POINT || mSource->mLayerType == QgsGrassProvider::TOPO_LINE ||
mSource->mEditing )
{
QgsDebugMsg( "Vect_select_lines_by_polygon" );
int type = mSource->mGrassType;
if ( mSource->mEditing )
{
type = GV_POINTS | GV_LINES;
}
QgsDebugMsg( QString( "type = %1" ).arg( type ) );
Vect_select_lines_by_polygon( mSource->map(), polygon, 0, NULL, type, list );
}
else if ( mSource->mLayerType == QgsGrassProvider::POLYGON )
{
Vect_select_areas_by_polygon( mSource->map(), polygon, 0, NULL, list );
}
else if ( mSource->mLayerType == QgsGrassProvider::TOPO_NODE )
{
// There is no Vect_select_nodes_by_polygon but for nodes it is the same as by box
Vect_select_nodes_by_box( mSource->map(), &box, list );
}
Vect_destroy_line_struct( polygon );
}
for ( int i = 0; i < list->n_values; i++ )
{
int lid = list->value[i];
if ( lid < 1 || lid >= mSelection.size() ) // should not happen
{
QgsDebugMsg( QString( "lid %1 out of range <1,%2>" ).arg( lid ).arg( mSelection.size() ) );
continue;
}
mSelection.setBit( lid );
}
Vect_destroy_list( list );
QgsDebugMsg( QString( " %1 features selected" ).arg( list->n_values ) );
QgsGrass::unlock();
}
/*!
\brief Render vector features into list
\param Map pointer to Map_info structure
\param box bounding box of region to be rendered
\param draw_flag types of objects to be rendered (see vedit.h)
\param center_easing, center_northing, map_width, map_height, map_res values used for conversion en->xy
\return pointer to robject_list structure
*/
struct robject_list *Vedit_render_map(struct Map_info *Map,
struct bound_box *box, int draw_flag,
double center_easting,
double center_northing, int map_width,
int map_height, double map_res)
{
int i, nfeat, fid;
struct ilist *list;
struct robject_list *list_obj;
struct robject *robj;
/* define region */
region.center_easting = center_easting;
region.center_northing = center_northing;
region.map_width = map_width;
region.map_height = map_height;
region.map_res = map_res;
region.map_west = center_easting - (map_width / 2.) * map_res;
region.map_north = center_northing + (map_height / 2.) * map_res;
list = Vect_new_list();
list_obj = NULL;
state.nitems_alloc = 1000;
list_obj = (struct robject_list *)G_malloc(sizeof(struct robject_list));
list_obj->nitems = 0;
list_obj->item =
(struct robject **)G_malloc(state.nitems_alloc *
sizeof(struct robject *));
/* area */
if (draw_flag & DRAW_AREA) {
nfeat = Vect_select_areas_by_box(Map, box, list);
for (i = 0; i < nfeat; i++) {
fid = list->value[i];
draw_area(Map, fid, list_obj);
}
}
/* draw lines inside of current display region */
nfeat = Vect_select_lines_by_box(Map, box, GV_POINTS | GV_LINES, /* fixme */
list);
G_debug(1, "Vedit_render_map(): region: w=%f, e=%f, s=%f, n=%f nlines=%d",
box->W, box->E, box->S, box->N, nfeat);
/* features */
for (i = 0; i < list->n_values; i++) {
fid = list->value[i];
robj = draw_line(Map, fid, draw_flag);
if (!robj)
continue;
list_append(list_obj, robj);
if (state.type & GV_LINES) {
/* vertices */
if (draw_flag & DRAW_VERTEX) {
robj = draw_line_vertices();
robj->fid = fid;
if (robj)
list_append(list_obj, robj);
}
/* nodes */
if (draw_flag & (DRAW_NODEONE | DRAW_NODETWO)) {
draw_line_nodes(Map, fid, draw_flag, list_obj);
}
/* direction */
if (draw_flag & DRAW_DIRECTION) {
draw_line_dir(list_obj, fid);
}
}
}
list_obj->item =
(struct robject **)G_realloc(list_obj->item,
list_obj->nitems *
sizeof(struct robject *));
Vect_destroy_list(list);
return list_obj;
}
/**
\brief Select features according to SQL where statement
\param[in] Map vector map
\param[in] layer layer number
\param[in] type feature type
\param[in] where 'where' statement
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_where(struct Map_info *Map,
int layer, int type, char *where, struct ilist *List)
{
struct cat_list *cat_list;
struct ilist *List_tmp;
struct field_info *Fi;
dbDriver *driver;
dbHandle handle;
int *cats, ncats;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
cat_list = Vect_new_cat_list();
if (layer < 1) {
G_fatal_error(_("Layer must be > 0 for 'where'"));
}
Fi = Vect_get_field(Map, layer);
if (!Fi) {
G_fatal_error(_("Database connection not defined for layer %d"),
layer);
}
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);
ncats = db_select_int(driver, Fi->table, Fi->key, where, &cats);
db_close_database(driver);
db_shutdown_driver(driver);
Vect_array_to_cat_list(cats, ncats, cat_list);
/* free array of cats */
if (ncats >= 0)
G_free(cats);
sel_by_cat(Map, cat_list, layer, type, NULL, List_tmp);
G_debug(1, " %d lines selected (by where)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
Vect_destroy_cat_list(cat_list);
return List->n_values;
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points, *PPoints;
struct line_cats *Cats, *TCats;
struct ilist *slist;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *catf_opt, *fieldf_opt, *wheref_opt;
struct Option *catt_opt, *fieldt_opt, *wheret_opt, *typet_opt;
struct Option *afield_opt, *nfield_opt, *abcol, *afcol, *ncol, *atype_opt;
struct Flag *geo_f, *segments_f;
int with_z, geo, segments;
int atype, ttype;
struct varray *varrayf, *varrayt;
int flayer, tlayer;
int afield, nfield;
dglGraph_s *graph;
struct ilist *nodest;
int i, j, nnodes, nlines;
int *dst, *nodes_to_features;
int from_nr; /* 'from' features not reachable */
dglInt32_t **nxt;
struct line_cats **on_path;
char *segdir;
char buf[2000];
/* Attribute table */
dbString sql;
dbDriver *driver;
struct field_info *Fi;
/* 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(_("network"));
G_add_keyword(_("shortest path"));
module->label = _("Computes shortest distance via the network between "
"the given sets of features.");
module->description =
_("Finds the shortest paths from each 'from' point to the nearest 'to' feature "
"and various information about this relation are uploaded to the attribute table.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "arc_layer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
atype_opt = G_define_standard_option(G_OPT_V_TYPE);
atype_opt->key = "arc_type";
atype_opt->options = "line,boundary";
atype_opt->answer = "line,boundary";
atype_opt->label = _("Arc type");
atype_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "node_layer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
fieldf_opt = G_define_standard_option(G_OPT_V_FIELD);
fieldf_opt->key = "from_layer";
fieldf_opt->label = _("From layer number or name");
fieldf_opt->guisection = _("From");
catf_opt = G_define_standard_option(G_OPT_V_CATS);
catf_opt->key = "from_cats";
catf_opt->label = _("From category values");
catf_opt->guisection = _("From");
wheref_opt = G_define_standard_option(G_OPT_DB_WHERE);
wheref_opt->key = "from_where";
wheref_opt->label =
_("From WHERE conditions of SQL statement without 'where' keyword");
wheref_opt->guisection = _("From");
fieldt_opt = G_define_standard_option(G_OPT_V_FIELD);
fieldt_opt->key = "to_layer";
fieldt_opt->description = _("To layer number or name");
fieldt_opt->guisection = _("To");
typet_opt = G_define_standard_option(G_OPT_V_TYPE);
typet_opt->key = "to_type";
typet_opt->options = "point,line,boundary";
typet_opt->answer = "point";
typet_opt->description = _("To feature type");
typet_opt->guisection = _("To");
catt_opt = G_define_standard_option(G_OPT_V_CATS);
catt_opt->key = "to_cats";
catt_opt->label = _("To category values");
catt_opt->guisection = _("To");
wheret_opt = G_define_standard_option(G_OPT_DB_WHERE);
wheret_opt->key = "to_where";
wheret_opt->label =
_("To WHERE conditions of SQL statement without 'where' keyword");
wheret_opt->guisection = _("To");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "arc_column";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_DB_COLUMN);
abcol->key = "arc_backward_column";
abcol->required = NO;
abcol->description = _("Arc backward direction cost column (number)");
abcol->guisection = _("Cost");
ncol = G_define_standard_option(G_OPT_DB_COLUMN);
ncol->key = "node_column";
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
segments_f = G_define_flag();
#if 0
/* use this to sync with v.net.path */
segments_f->key = 's';
segments_f->description = _("Write output as original input segments, "
"not each path as one line.");
#else
segments_f->key = 'l';
segments_f->description = _("Write each output path as one line, "
"not as original input segments.");
#endif
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
atype = Vect_option_to_types(atype_opt);
ttype = Vect_option_to_types(typet_opt);
Points = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
TCats = Vect_new_cats_struct();
slist = G_new_ilist();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
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 (geo_f->answer) {
geo = 1;
if (G_projection() != PROJECTION_LL)
G_warning(_("The current projection is not longitude-latitude"));
}
else
geo = 0;
#if 0
/* use this to sync with v.net.path */
segments = segments_f->answer;
#else
segments = !segments_f->answer;
#endif
nnodes = Vect_get_num_nodes(&In);
nlines = Vect_get_num_lines(&In);
dst = (int *)G_calloc(nnodes + 1, sizeof(int));
nxt = (dglInt32_t **) G_calloc(nnodes + 1, sizeof(dglInt32_t *));
nodes_to_features = (int *)G_calloc(nnodes + 1, sizeof(int));
on_path =
(struct line_cats **)G_calloc(nlines + 1, sizeof(struct line_cats *));
segdir = (char *)G_calloc(nlines + 1, sizeof(char));
if (!dst || !nxt || !nodes_to_features || !on_path || !segdir)
G_fatal_error(_("Out of memory"));
for (i = 1; i <= nlines; i++) {
on_path[i] = Vect_new_cats_struct();
segdir[i] = 0;
}
/*initialise varrays and nodes list appropriatelly */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
flayer = atoi(fieldf_opt->answer);
tlayer = atoi(fieldt_opt->answer);
if (NetA_initialise_varray(&In, flayer, GV_POINT, wheref_opt->answer,
catf_opt->answer, &varrayf) <= 0) {
G_fatal_error(_("No 'from' features selected. "
"Please check options '%s', '%s', '%s'."),
fieldf_opt->key, wheref_opt->key, catf_opt->key);
}
if (NetA_initialise_varray(&In, tlayer, ttype, wheret_opt->answer,
catt_opt->answer, &varrayt) <= 0) {
G_fatal_error(_("No 'to' features selected. "
"Please check options '%s', '%s', '%s'."),
fieldt_opt->key, wheret_opt->key, catt_opt->key);
}
nodest = Vect_new_list();
NetA_varray_to_nodes(&In, varrayt, nodest, nodes_to_features);
if (nodest->n_values == 0)
G_fatal_error(_("No 'to' features"));
if (0 != Vect_net_build_graph(&In, atype, afield, nfield, afcol->answer, abcol->answer,
ncol->answer, geo, 2))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
G_message(_("Distances to 'to' features ..."));
NetA_distance_to_points(graph, nodest, dst, nxt);
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
db_init_string(&sql);
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);
sprintf(buf,
"create table %s ( cat integer, tcat integer, dist double precision)",
Fi->table);
db_set_string(&sql, buf);
G_debug(2, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
G_message(_("Tracing paths from 'from' features ..."));
from_nr = 0;
for (i = 1; i <= nlines; i++) {
if (varrayf->c[i]) {
int type = Vect_read_line(&In, Points, Cats, i);
int node, tcat, cat;
double cost;
dglInt32_t *vertex, vertex_id;
if (!Vect_cat_get(Cats, flayer, &cat))
continue;
if (type & GV_POINTS) {
node = Vect_find_node(&In, Points->x[0], Points->y[0], Points->z[0], 0, 0);
}
else {
Vect_get_line_nodes(&In, i, &node, NULL);
}
if (node < 1)
continue;
if (dst[node] < 0) {
/* unreachable */
from_nr++;
continue;
}
cost = dst[node] / (double)In.dgraph.cost_multip;
vertex = dglGetNode(graph, node);
vertex_id = node;
slist->n_values = 0;
while (nxt[vertex_id] != NULL) {
int edge_id;
edge_id = (int) dglEdgeGet_Id(graph, nxt[vertex_id]);
if (segments) {
Vect_cat_set(on_path[abs(edge_id)], 1, cat);
if (edge_id < 0) {
segdir[abs(edge_id)] = 1;
}
}
else
G_ilist_add(slist, edge_id);
vertex = dglEdgeGet_Tail(graph, nxt[vertex_id]);
vertex_id = dglNodeGet_Id(graph, vertex);
}
G_debug(3, "read line %d, vertex id %d", nodes_to_features[vertex_id], (int)vertex_id);
Vect_read_line(&In, NULL, TCats, nodes_to_features[vertex_id]);
if (!Vect_cat_get(TCats, tlayer, &tcat))
continue;
Vect_write_line(&Out, type, Points, Cats);
sprintf(buf, "insert into %s values (%d, %d, %f)", Fi->table, cat,
tcat, cost);
db_set_string(&sql, buf);
G_debug(3, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new record: %s"),
db_get_string(&sql));
};
if (!segments) {
Vect_reset_line(PPoints);
for (j = 0; j < slist->n_values; j++) {
Vect_read_line(&In, Points, NULL, abs(slist->value[j]));
if (slist->value[j] > 0)
Vect_append_points(PPoints, Points,
GV_FORWARD);
else
Vect_append_points(PPoints, Points,
GV_BACKWARD);
PPoints->n_points--;
}
PPoints->n_points++;
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, GV_LINE, PPoints, Cats);
}
}
}
if (segments) {
for (i = 1; i <= nlines; i++) {
if (on_path[i]->n_cats > 0) {
int type;
if (segdir[i]) {
type = Vect_read_line(&In, PPoints, NULL, i);
Vect_reset_line(Points);
Vect_append_points(Points, PPoints, GV_BACKWARD);
}
else
type = Vect_read_line(&In, Points, NULL, i);
Vect_write_line(&Out, type, Points, on_path[i]);
}
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
for (i = 1; i <= nlines; i++)
Vect_destroy_cats_struct(on_path[i]);
G_free(on_path);
G_free(nodes_to_features);
G_free(dst);
G_free(nxt);
G_free(segdir);
if (from_nr)
G_warning(n_("%d 'from' feature was not reachable",
"%d 'from' features were not reachable",
from_nr), from_nr);
exit(EXIT_SUCCESS);
}
/*!
\brief Connect lines in given threshold
\code
\ \
id1 \ -> \
\
id2 --------- -----+---
\endcode
If two lines are selected and <i>thresh</i> is -1, no limit is
applied.
\param Map pointer to Map_info
\param List list of selected lines
\param thresh threshold value
\return number of modified lines
\return -1 on error
*/
int Vedit_connect_lines(struct Map_info *Map, struct ilist *List,
double thresh)
{
int nlines_modified, connected;
int i, j, node[2], n_nodes;
int line, found;
double x, y, z;
struct ilist *List_exclude, *List_found;
nlines_modified = 0;
List_exclude = Vect_new_list();
List_found = Vect_new_list();
n_nodes = 2;
/* collect lines to be modified */
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
if (!Vect_line_alive(Map, line))
continue;
if (Vect_get_line_type(Map, line) & GV_POINTS)
continue;
node[0] = node[1] = -1;
Vect_get_line_nodes(Map, line, &(node[0]), &(node[1]));
if (node[0] < 0 || node[1] < 0)
continue;
connected = 0;
Vect_reset_list(List_exclude);
Vect_list_append(List_exclude, line);
for (j = 0; j < n_nodes && !connected; j++) {
/* for each line node find lines in threshold */
Vect_get_node_coor(Map, node[j], &x, &y, &z);
do {
/* find first nearest line */
found = Vect_find_line_list(Map, x, y, z,
GV_LINES, thresh, WITHOUT_Z,
List_exclude, List_found);
if (found > 0 && Vect_line_alive(Map, found)) {
/* try to connect lines (given node) */
G_debug(3, "Vedit_connect_lines(): lines=%d,%d", line, found);
if (connect_lines(Map, !j, line, found, thresh, List)) {
G_debug(3, "Vedit_connect_lines(): lines=%d,%d -> connected",
line, found);
nlines_modified += 2;
connected = 1;
}
}
Vect_list_append(List_exclude, found);
} while(List_found->n_values > 0 && !connected);
}
}
Vect_destroy_list(List_exclude);
Vect_destroy_list(List_found);
return nlines_modified;
}
/**
\brief Select vector features
\param[in] Map vector map
\param[in] action_mode tool
\param[in] params GRASS parameters
\param[in] List list of selected features
\return list of newly selected features
*/
struct ilist *select_lines(struct Map_info *Map, enum mode action_mode,
struct GParams *params, double *thresh,
struct ilist *List)
{
int layer, type;
layer = atoi(params->fld->answer);
type = Vect_option_to_types(params->type);
/* select by id's */
if (params->id->answer != NULL) {
sel_by_id(Map, type, params->id->answer, List);
}
/* select by category (ignore tools catdel and catadd) */
if ((action_mode != MODE_CATADD && action_mode != MODE_CATDEL) &&
params->cat->answer != NULL) {
sel_by_cat(Map, NULL, layer, type, params->cat->answer, List);
}
/* select by coordinates (+threshold) */
if (params->coord->answer != NULL) {
int i;
double east, north;
struct line_pnts *coords;
coords = Vect_new_line_struct();
i = 0;
while (params->coord->answers[i]) {
east = atof(params->coord->answers[i]);
north = atof(params->coord->answers[i + 1]);
Vect_append_point(coords, east, north, 0.0);
i += 2;
}
G_verbose_message(_("Threshold value for coordinates is %.2f"),
thresh[THRESH_COORDS]);
sel_by_coordinates(Map, type, coords, thresh[THRESH_COORDS], List);
Vect_destroy_line_struct(coords);
}
/* select by bbox */
if (params->bbox->answer != NULL) {
struct line_pnts *bbox;
double x1, y1, x2, y2;
bbox = Vect_new_line_struct();
x1 = atof(params->bbox->answers[0]);
y1 = atof(params->bbox->answers[1]);
x2 = atof(params->bbox->answers[2]);
y2 = atof(params->bbox->answers[3]);
Vect_append_point(bbox, x1, y1, -PORT_DOUBLE_MAX);
Vect_append_point(bbox, x2, y1, PORT_DOUBLE_MAX);
Vect_append_point(bbox, x2, y2, -PORT_DOUBLE_MAX);
Vect_append_point(bbox, x1, y2, PORT_DOUBLE_MAX);
Vect_append_point(bbox, x1, y1, -PORT_DOUBLE_MAX);
/* sel_by_bbox not used */
/*
sel_by_bbox(Map,
type, x1, y1, x2, y2,
List);
*/
sel_by_polygon(Map, type, bbox, List);
Vect_destroy_line_struct(bbox);
}
/* select by polygon */
if (params->poly->answer != NULL) {
int i;
struct line_pnts *Polygon;
Polygon = Vect_new_line_struct();
for (i = 0; params->poly->answers[i]; i += 2) {
Vect_append_point(Polygon,
atof(params->poly->answers[i]),
atof(params->poly->answers[i + 1]), 0.0);
}
/* if first and last point of polygon does not match */
if (atof(params->poly->answers[i - 1]) !=
atof(params->poly->answers[0])) {
Vect_append_point(Polygon, atof(params->poly->answers[0]),
atof(params->poly->answers[1]), 0.0);
}
sel_by_polygon(Map, type, Polygon, List);
Vect_destroy_line_struct(Polygon);
}
/* select by where statement */
if (params->where->answer != NULL) {
sel_by_where(Map, layer, type, params->where->answer, List);
}
/* selecy by query */
if (params->query->answer != NULL) {
int query_type;
struct ilist *List_tmp;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
query_type = QUERY_UNKNOWN;
if (strcmp(params->query->answer, "length") == 0) {
query_type = QUERY_LENGTH;
}
else if (strcmp(params->query->answer, "dangle") == 0) {
query_type = QUERY_DANGLE;
}
G_verbose_message(_("Threshold value for querying is %.2f"),
thresh[THRESH_QUERY]);
Vedit_select_by_query(Map, type, layer, thresh[THRESH_QUERY],
query_type, List_tmp);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
}
if (params->reverse->answer) {
reverse_selection(Map, type, &List);
}
G_message(_("%d of %d features selected from vector map <%s>"),
List->n_values,
Vect_get_num_lines(Map), Vect_get_full_name(Map));
return List;
}
/*!
\brief Split selected lines on given position
\param Map pointer to Map_info
\param List list of selected lines
\param coord points location
\param thresh threshold
\param[out] List_updated list of rewritten features (or NULL)
\return number of modified lines
\return -1 on error
*/
int Vedit_split_lines(struct Map_info *Map, struct ilist *List,
struct line_pnts *coord, double thresh,
struct ilist *List_updated)
{
int i, j, l;
int type, line, seg, newline;
int nlines_modified;
double px, py, spdist, lpdist, dist;
double *x, *y, *z;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
struct ilist *List_in_box;
nlines_modified = 0;
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List_in_box = Vect_new_list();
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, Points, Cats, line);
if (!(type & GV_LINES))
continue;
x = Points->x;
y = Points->y;
z = Points->z;
for (j = 0; j < coord->n_points; j++) {
seg =
Vect_line_distance(Points, coord->x[j], coord->y[j],
coord->z[j], WITHOUT_Z, &px, &py, NULL,
&dist, &spdist, &lpdist);
if (dist > thresh) {
continue;
}
G_debug(3, "Vedit_split_lines(): line=%d, x=%f, y=%f, px=%f, py=%f, seg=%d, "
"dist=%f, spdist=%f, lpdist=%f", line, coord->x[j],
coord->y[j], px, py, seg, dist, spdist, lpdist);
if (spdist <= 0.0 || spdist >= Vect_line_length(Points))
continue;
G_debug(3, "Vedit_split_lines(): line=%d", line);
/* copy first line part */
for (l = 0; l < seg; l++) {
Vect_append_point(Points2, x[l], y[l], z[l]);
}
/* add last vertex */
Vect_append_point(Points2, px, py, 0.0);
/* rewrite the line */
newline = Vect_rewrite_line(Map, line, type, Points2, Cats);
if (newline < 0) {
return -1;
}
if (List_updated)
Vect_list_append(List_updated, newline);
Vect_reset_line(Points2);
/* add given vertex */
Vect_append_point(Points2, px, py, 0.0);
/* copy second line part */
for (l = seg; l < Points->n_points; l++) {
Vect_append_point(Points2, x[l], y[l], z[l]);
}
/* rewrite the line */
newline = Vect_write_line(Map, type, Points2, Cats);
if (newline < 0) {
return -1;
}
if (List_updated)
Vect_list_append(List_updated, newline);
nlines_modified++;
} /* for each bounding box */
} /* for each selected line */
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Points2);
Vect_destroy_cats_struct(Cats);
Vect_destroy_list(List_in_box);
return nlines_modified;
}
int 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;
}
/*
Called by Vect_remove_bridges() and Vect_chtype_bridges():
chtype = 0 -> works like Vect_remove_bridges()
chtype = 1 -> works like Vect_chtype_bridges()
Algorithm: Go thorough all lines,
if both sides of the line have left and side 0 (candidate) do this check:
follow adjacent lines in one direction (nearest to the right at the end node),
if we reach this line again without dangle in the way, but with this line
traversed from other side it is a bridge.
List of all lines in chain is created during the cycle.
*/
void
remove_bridges(struct Map_info *Map, int chtype, struct Map_info *Err)
{
int i, type, nlines, line;
int left, right, node1, node2, current_line, next_line;
int bridges_removed = 0; /* number of removed bridges */
int lines_removed = 0; /* number of lines removed */
char *lmsg;
struct Plus_head *Plus;
struct line_pnts *Points;
struct line_cats *Cats;
struct ilist *CycleList;
struct ilist *BridgeList;
int dangle, other_side;
if (chtype)
lmsg = "changed lines";
else
lmsg = "removed lines";
Plus = &(Map->plus);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
CycleList = Vect_new_list();
BridgeList = Vect_new_list();
nlines = Vect_get_num_lines(Map);
G_debug(1, "nlines = %d", nlines);
for (line = 1; line <= nlines; line++) {
G_percent(line, nlines, 1);
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, NULL, NULL, line);
if (!(type & GV_BOUNDARY))
continue;
Vect_get_line_areas(Map, line, &left, &right);
if (left != 0 || right != 0)
continue; /* Cannot be bridge */
G_debug(2, "line %d - bridge candidate", line);
Vect_get_line_nodes(Map, line, &node1, &node2);
if (abs(node1) == abs(node2))
continue; /* either zero length or loop -> cannot be a bridge */
current_line = -line; /* we start with negative (go forward, node2 ) */
dangle = 0;
other_side = 0;
Vect_reset_list(CycleList);
Vect_reset_list(BridgeList);
while (1) {
next_line =
dig_angle_next_line(Plus, current_line, GV_RIGHT,
GV_BOUNDARY);
/* Add this line to the list */
/* TODO: Vect_val_in_list() and Vect_list_append() behave O(n)
* change to O(log n) */
if (Vect_val_in_list(CycleList, abs(next_line))) /* other side -> bridge chain */
Vect_list_append(BridgeList, abs(next_line));
else
dig_list_add(CycleList, abs(next_line)); /* not in list, can add new line fast */
if (abs(next_line) == abs(current_line)) {
G_debug(4, " dangle -> no bridge");
dangle = 1;
break;
}
if (abs(next_line) == line) { /* start line reached */
/* which side */
if (next_line < 0) { /* other side (connected by node 2) */
G_debug(5, " other side reached");
other_side = 1;
}
else { /* start side */
break;
}
}
current_line = -next_line; /* change the sign to look at the next node in following cycle */
}
if (!dangle && other_side) {
G_debug(3, " line %d is part of bridge chain", line);
for (i = 0; i < BridgeList->n_values; i++) {
Vect_read_line(Map, Points, Cats, BridgeList->value[i]);
if (Err) {
Vect_write_line(Err, GV_BOUNDARY, Points, Cats);
}
if (!chtype)
Vect_delete_line(Map, BridgeList->value[i]);
else
Vect_rewrite_line(Map, BridgeList->value[i], GV_LINE,
Points, Cats);
lines_removed++;
}
bridges_removed++;
}
}
G_verbose_message("Removed lines: %d", lines_removed);
G_verbose_message("Removed bridges: %d", bridges_removed);
}
/*!
\brief 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 GModule *module;
struct GParams params;
struct Map_info Map;
struct Map_info **BgMap; /* backgroud vector maps */
int nbgmaps; /* number of registrated background maps */
enum mode action_mode;
FILE *ascii;
int i;
int move_first, snap;
int ret, layer;
double move_x, move_y, move_z, thresh[3];
struct line_pnts *coord;
struct ilist *List;
struct cat_list *Clist;
ascii = NULL;
List = NULL;
BgMap = NULL;
nbgmaps = 0;
coord = NULL;
Clist = NULL;
G_gisinit(argv[0]);
module = G_define_module();
module->overwrite = TRUE;
G_add_keyword(_("vector"));
G_add_keyword(_("editing"));
G_add_keyword(_("geometry"));
module->description = _("Edits a vector map, allows adding, deleting "
"and modifying selected vector features.");
if (!parser(argc, argv, ¶ms, &action_mode))
exit(EXIT_FAILURE);
/* get list of categories */
Clist = Vect_new_cat_list();
if (params.cat->answer && Vect_str_to_cat_list(params.cat->answer, Clist)) {
G_fatal_error(_("Unable to get category list <%s>"),
params.cat->answer);
}
/* open input file */
if (params.in->answer) {
if (strcmp(params.in->answer, "-") != 0) {
ascii = fopen(params.in->answer, "r");
if (ascii == NULL)
G_fatal_error(_("Unable to open file <%s>"),
params.in->answer);
}
else {
ascii = stdin;
}
}
if (!ascii && action_mode == MODE_ADD)
G_fatal_error(_("Required parameter <%s> not set"), params.in->key);
if (action_mode == MODE_CREATE) {
int overwrite;
overwrite = G_check_overwrite(argc, argv);
if (G_find_vector2(params.map->answer, G_mapset())) {
if (!overwrite)
G_fatal_error(_("Vector map <%s> already exists"),
params.map->answer);
}
/* 3D vector maps? */
ret = Vect_open_new(&Map, params.map->answer, WITHOUT_Z);
if (Vect_maptype(&Map) == GV_FORMAT_OGR_DIRECT) {
int type;
type = Vect_option_to_types(params.type);
if (type != GV_POINT && type != GV_LINE &&
type != GV_BOUNDARY)
G_fatal_error(_("Supported feature type for OGR layer: "
"%s, %s or %s"), "point", "line", "boundary");
V2_open_new_ogr(&Map, type);
}
if (ret == -1) {
G_fatal_error(_("Unable to create vector map <%s>"),
params.map->answer);
}
G_debug(1, "Map created");
if (ascii) {
/* also add new vector features */
action_mode = MODE_ADD;
}
}
else { /* open selected vector file */
if (action_mode == MODE_ADD) /* write */
ret = Vect_open_update2(&Map, params.map->answer, G_mapset(), params.fld->answer);
else /* read-only -- select features */
ret = Vect_open_old2(&Map, params.map->answer, G_mapset(), params.fld->answer);
if (ret < 2)
G_fatal_error(_("Unable to open vector map <%s> at topological level %d"),
params.map->answer, 2);
}
G_debug(1, "Map opened");
/* open backgroud maps */
if (params.bmaps->answer) {
i = 0;
while (params.bmaps->answers[i]) {
const char *bmap = params.bmaps->answers[i];
const char *mapset = G_find_vector2(bmap, "");
if (!mapset)
G_fatal_error(_("Vector map <%s> not found"), bmap);
if (strcmp(
G_fully_qualified_name(params.map->answer, G_mapset()),
G_fully_qualified_name(bmap, mapset)) == 0) {
G_fatal_error(_("Unable to open vector map <%s> as the background map. "
"It is given as vector map to be edited."),
bmap);
}
nbgmaps++;
BgMap = (struct Map_info **)G_realloc(
BgMap, nbgmaps * sizeof(struct Map_info *));
BgMap[nbgmaps - 1] =
(struct Map_info *)G_malloc(sizeof(struct Map_info));
if (Vect_open_old(BgMap[nbgmaps - 1], bmap, "") == -1)
G_fatal_error(_("Unable to open vector map <%s>"), bmap);
G_verbose_message(_("Background vector map <%s> registered"), bmap);
i++;
}
}
layer = Vect_get_field_number(&Map, params.fld->answer);
i = 0;
while (params.maxdist->answers[i]) {
switch (i) {
case THRESH_COORDS:
thresh[THRESH_COORDS] =
max_distance(atof(params.maxdist->answers[THRESH_COORDS]));
thresh[THRESH_SNAP] = thresh[THRESH_QUERY] =
thresh[THRESH_COORDS];
break;
case THRESH_SNAP:
thresh[THRESH_SNAP] =
max_distance(atof(params.maxdist->answers[THRESH_SNAP]));
break;
case THRESH_QUERY:
thresh[THRESH_QUERY] =
atof(params.maxdist->answers[THRESH_QUERY]);
break;
default:
break;
}
i++;
}
move_first = params.move_first->answer ? 1 : 0;
snap = NO_SNAP;
if (strcmp(params.snap->answer, "node") == 0)
snap = SNAP;
else if (strcmp(params.snap->answer, "vertex") == 0)
snap = SNAPVERTEX;
if (snap != NO_SNAP && thresh[THRESH_SNAP] <= 0) {
G_warning(_("Threshold for snapping must be > 0. No snapping applied."));
snap = NO_SNAP;
}
if (action_mode != MODE_CREATE && action_mode != MODE_ADD) {
/* select lines */
List = Vect_new_list();
G_message(_("Selecting features..."));
if (action_mode == MODE_COPY && BgMap && BgMap[0]) {
List = select_lines(BgMap[0], action_mode, ¶ms, thresh, List);
}
else {
List = select_lines(&Map, action_mode, ¶ms, thresh, List);
}
}
if ((action_mode != MODE_CREATE && action_mode != MODE_ADD &&
action_mode != MODE_SELECT)) {
if (List->n_values < 1) {
G_warning(_("No features selected, nothing to edit"));
action_mode = MODE_NONE;
ret = 0;
}
else {
/* reopen the map for updating */
if (action_mode == MODE_ZBULK && !Vect_is_3d(&Map)) {
Vect_close(&Map);
G_fatal_error(_("Vector map <%s> is not 3D. Tool '%s' requires 3D vector map. "
"Please convert the vector map "
"to 3D using e.g. %s."), params.map->answer,
params.tool->answer, "v.extrude");
}
Vect_close(&Map);
Vect_open_update2(&Map, params.map->answer, G_mapset(), params.fld->answer);
}
}
/* coords option -> array */
if (params.coord->answers) {
coord = Vect_new_line_struct();
int i = 0;
double east, north;
while (params.coord->answers[i]) {
east = atof(params.coord->answers[i]);
north = atof(params.coord->answers[i + 1]);
Vect_append_point(coord, east, north, 0.0);
i += 2;
}
}
/* perform requested editation */
switch (action_mode) {
case MODE_CREATE:
break;
case MODE_ADD:
if (!params.header->answer)
Vect_read_ascii_head(ascii, &Map);
int num_lines;
num_lines = Vect_get_num_lines(&Map);
ret = Vect_read_ascii(ascii, &Map);
G_message(_("%d features added"), ret);
if (ret > 0) {
int iline;
struct ilist *List_added;
List_added = Vect_new_list();
for (iline = num_lines + 1; iline <= Vect_get_num_lines(&Map); iline++)
Vect_list_append(List_added, iline);
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
if (snap != NO_SNAP) { /* apply snapping */
/* snap to vertex ? */
Vedit_snap_lines(&Map, BgMap, nbgmaps, List_added,
thresh[THRESH_SNAP],
snap == SNAP ? FALSE : TRUE);
}
if (params.close->answer) { /* close boundaries */
int nclosed;
nclosed = close_lines(&Map, GV_BOUNDARY, thresh[THRESH_SNAP]);
G_message(_("%d boundaries closed"), nclosed);
}
Vect_destroy_list(List_added);
}
break;
case MODE_DEL:
ret = Vedit_delete_lines(&Map, List);
G_message(_("%d features deleted"), ret);
break;
case MODE_MOVE:
move_x = atof(params.move->answers[0]);
move_y = atof(params.move->answers[1]);
move_z = atof(params.move->answers[2]);
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = Vedit_move_lines(&Map, BgMap, nbgmaps, List, move_x, move_y, move_z, snap, thresh[THRESH_SNAP]);
G_message(_("%d features moved"), ret);
break;
case MODE_VERTEX_MOVE:
move_x = atof(params.move->answers[0]);
move_y = atof(params.move->answers[1]);
move_z = atof(params.move->answers[2]);
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = Vedit_move_vertex(&Map, BgMap, nbgmaps, List, coord, thresh[THRESH_COORDS], thresh[THRESH_SNAP], move_x, move_y, move_z, move_first, snap);
G_message(_("%d vertices moved"), ret);
break;
case MODE_VERTEX_ADD:
ret = Vedit_add_vertex(&Map, List, coord, thresh[THRESH_COORDS]);
G_message(_("%d vertices added"), ret);
break;
case MODE_VERTEX_DELETE:
ret = Vedit_remove_vertex(&Map, List, coord, thresh[THRESH_COORDS]);
G_message(_("%d vertices removed"), ret);
break;
case MODE_BREAK:
if (params.coord->answer) {
ret = Vedit_split_lines(&Map, List,
coord, thresh[THRESH_COORDS], NULL);
}
else {
ret = Vect_break_lines_list(&Map, List, NULL, GV_LINES, NULL);
}
G_message(_("%d lines broken"), ret);
break;
case MODE_CONNECT:
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = Vedit_connect_lines(&Map, List, thresh[THRESH_SNAP]);
G_message(_("%d lines connected"), ret);
break;
case MODE_MERGE:
ret = Vedit_merge_lines(&Map, List);
G_message(_("%d lines merged"), ret);
break;
case MODE_SELECT:
ret = print_selected(List);
break;
case MODE_CATADD:
ret = Vedit_modify_cats(&Map, List, layer, 0, Clist);
G_message(_("%d features modified"), ret);
break;
case MODE_CATDEL:
ret = Vedit_modify_cats(&Map, List, layer, 1, Clist);
G_message(_("%d features modified"), ret);
break;
case MODE_COPY:
if (BgMap && BgMap[0]) {
if (nbgmaps > 1)
G_warning(_("Multiple background maps were given. "
"Selected features will be copied only from "
"vector map <%s>."),
Vect_get_full_name(BgMap[0]));
ret = Vedit_copy_lines(&Map, BgMap[0], List);
}
else {
ret = Vedit_copy_lines(&Map, NULL, List);
}
G_message(_("%d features copied"), ret);
break;
case MODE_SNAP:
G_verbose_message(_("Threshold value for snapping is %.2f"),
thresh[THRESH_SNAP]);
ret = snap_lines(&Map, List, thresh[THRESH_SNAP]);
break;
case MODE_FLIP:
ret = Vedit_flip_lines(&Map, List);
G_message(_("%d lines flipped"), ret);
break;
case MODE_NONE:
break;
case MODE_ZBULK:{
double start, step;
double x1, y1, x2, y2;
start = atof(params.zbulk->answers[0]);
step = atof(params.zbulk->answers[1]);
x1 = atof(params.bbox->answers[0]);
y1 = atof(params.bbox->answers[1]);
x2 = atof(params.bbox->answers[2]);
y2 = atof(params.bbox->answers[3]);
ret = Vedit_bulk_labeling(&Map, List,
x1, y1, x2, y2, start, step);
G_message(_("%d lines labeled"), ret);
break;
}
case MODE_CHTYPE:{
ret = Vedit_chtype_lines(&Map, List);
if (ret > 0) {
G_message(_("%d features converted"), ret);
}
else {
G_message(_("No feature modified"));
}
break;
}
default:
G_warning(_("Operation not implemented"));
ret = -1;
break;
}
Vect_hist_command(&Map);
/* build topology only if requested or if tool!=select */
if (!(action_mode == MODE_SELECT || params.topo->answer == 1 ||
!MODE_NONE)) {
Vect_build_partial(&Map, GV_BUILD_NONE);
Vect_build(&Map);
}
if (List)
Vect_destroy_list(List);
Vect_close(&Map);
G_debug(1, "Map closed");
/* close background maps */
for (i = 0; i < nbgmaps; i++) {
Vect_close(BgMap[i]);
G_free((void *)BgMap[i]);
}
G_free((void *)BgMap);
if (coord)
Vect_destroy_line_struct(coord);
if (Clist)
Vect_destroy_cat_list(Clist);
G_done_msg(" ");
if (ret > -1) {
exit(EXIT_SUCCESS);
}
else {
exit(EXIT_FAILURE);
}
}
/* merge a given line with all other lines of the same type and
* with the same categories */
static int merge_line(struct Map_info *Map, int line,
struct line_pnts *MPoints, struct line_cats *MCats)
{
int nlines, i, first, last, next_line, curr_line;
int merged = 0, newl = 0;
int next_node, direction, node_n_lines, type, ltype, lines_type;
static struct ilist *List = NULL;
static struct line_pnts *Points = NULL;
static struct line_cats *Cats = NULL;
type = GV_LINE;
nlines = Vect_get_num_lines(Map);
if (!Points)
Points = Vect_new_line_struct();
if (!Cats)
Cats = Vect_new_cats_struct();
if (!List)
List = Vect_new_list();
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_reset_cats(MCats);
Vect_reset_list(List);
if (!Vect_line_alive(Map, line))
return 0;
ltype = Vect_get_line_type(Map, line);
if (!(ltype & type))
return 0;
Vect_read_line(Map, MPoints, MCats, line);
/* special cases:
* - loop back to start boundary via several other boundaries
* - one boundary forming closed loop
* - node with 3 entries but only 2 boundaries, one of them connecting twice,
* the other one must then be topologically incorrect in case of boundary */
/* go backward as long as there is only one other line/boundary at the current node */
G_debug(3, "go backward");
Vect_get_line_nodes(Map, line, &next_node, NULL);
first = -line;
while (1) {
node_n_lines = Vect_get_node_n_lines(Map, next_node);
/* count lines/boundaries at this node */
lines_type = 0;
next_line = first;
for (i = 0; i < node_n_lines; i++) {
curr_line = Vect_get_node_line(Map, next_node, i);
if ((Vect_get_line_type(Map, abs(curr_line)) & GV_LINES))
lines_type++;
if ((Vect_get_line_type(Map, abs(curr_line)) == ltype)) {
if (abs(curr_line) != abs(first)) {
Vect_read_line(Map, NULL, Cats, abs(curr_line));
/* catgories must be identical */
if (compare_cats(MCats, Cats) == 0)
next_line = curr_line;
}
}
}
if (lines_type == 2 && abs(next_line) != abs(first) &&
abs(next_line) != line) {
first = next_line;
if (first < 0) {
Vect_get_line_nodes(Map, -first, &next_node, NULL);
}
else {
Vect_get_line_nodes(Map, first, NULL, &next_node);
}
}
else
break;
}
/* go forward as long as there is only one other line/boundary at the current node */
G_debug(3, "go forward");
/* reverse direction */
last = -first;
if (last < 0) {
Vect_get_line_nodes(Map, -last, &next_node, NULL);
}
else {
Vect_get_line_nodes(Map, last, NULL, &next_node);
}
Vect_reset_list(List);
while (1) {
G_ilist_add(List, last);
node_n_lines = Vect_get_node_n_lines(Map, next_node);
lines_type = 0;
next_line = last;
for (i = 0; i < node_n_lines; i++) {
curr_line = Vect_get_node_line(Map, next_node, i);
if ((Vect_get_line_type(Map, abs(curr_line)) & GV_LINES))
lines_type++;
if ((Vect_get_line_type(Map, abs(curr_line)) == ltype)) {
if (abs(curr_line) != abs(last)) {
Vect_read_line(Map, NULL, Cats, abs(curr_line));
if (compare_cats(MCats, Cats) == 0)
next_line = curr_line;
}
}
}
if (lines_type == 2 && abs(next_line) != abs(last) &&
abs(next_line) != abs(first)) {
last = next_line;
if (last < 0) {
Vect_get_line_nodes(Map, -last, &next_node, NULL);
}
else {
Vect_get_line_nodes(Map, last, NULL, &next_node);
}
}
else
break;
}
/* merge lines */
G_debug(3, "merge %d lines", List->n_values);
Vect_reset_line(MPoints);
for (i = 0; i < List->n_values; i++) {
Vect_reset_line(Points);
Vect_read_line(Map, Points, Cats, abs(List->value[i]));
direction = (List->value[i] < 0 ? GV_BACKWARD : GV_FORWARD);
Vect_append_points(MPoints, Points, direction);
MPoints->n_points--;
Vect_delete_line(Map, abs(List->value[i]));
}
MPoints->n_points++;
merged += List->n_values;
newl++;
return merged;
}
int report(struct Map_info *In, int afield, int nfield, int action)
{
int i, j, line, nlines, ltype, node, nnodes;
int cat_line, cat_node[2];
struct line_cats *Cats, *Cats2;
struct line_pnts *Points;
struct bound_box box;
double x, y, z;
Cats = Vect_new_cats_struct();
Cats2 = Vect_new_cats_struct();
Points = Vect_new_line_struct();
nlines = Vect_get_num_lines(In);
if (action == TOOL_REPORT) {
struct boxlist *List;
List = Vect_new_boxlist(0);
/* For all lines find categories for points on nodes */
for (i = 1; i <= nlines; i++) {
ltype = Vect_read_line(In, NULL, Cats, i);
if (!(ltype & GV_LINES))
continue;
cat_line = 0;
if (!Vect_cat_get(Cats, afield, &cat_line))
G_warning(_("Line %d has no category"), i);
cat_node[0] = cat_node[1] = -1;
for (j = 0; j < 2; j++) {
if (j == 0)
Vect_get_line_nodes(In, i, &node, NULL);
else
Vect_get_line_nodes(In, i, NULL, &node);
Vect_get_node_coor(In, node, &x, &y, &z);
box.E = box.W = x;
box.N = box.S = y;
box.T = box.B = z;
Vect_select_lines_by_box(In, &box, GV_POINT, List);
nnodes = List->n_values;
if (nnodes > 0) {
line = List->id[nnodes - 1]; /* last in list */
Vect_read_line(In, NULL, Cats, line);
Vect_cat_get(Cats, nfield, &(cat_node[j]));
}
if (nnodes == 0) {
/* this is ok, not every node needs to be
* represented by a point */
G_debug(4, "No point here: %g %g %.g line category: %d",
x, y, z, cat_line);
}
else if (nnodes > 1)
G_warning(_("%d points found: %g %g %g line category: %d"),
nnodes, x, y, z, cat_line);
}
fprintf(stdout, "%d %d %d\n", cat_line, cat_node[0], cat_node[1]);
}
}
else { /* node report */
int elem, nelem, type, k, l;
struct ilist *List;
List = Vect_new_list();
for (i = 1; i <= nlines; i++) {
if (Vect_get_line_type(In, i) != GV_POINT)
continue;
Vect_read_line(In, Points, Cats, i);
box.E = box.W = Points->x[0];
box.N = box.S = Points->y[0];
box.T = box.B = Points->z[0];
nnodes = Vect_select_nodes_by_box(In, &box, List);
if (nnodes > 1) {
G_warning(_("Duplicate nodes at x=%g y=%g z=%g "),
Points->x[0], Points->y[0], Points->z[0]);
}
if (nnodes > 0) {
node = List->value[0];
nelem = Vect_get_node_n_lines(In, node);
/* Loop through all cats of point */
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == nfield) {
int count = 0;
fprintf(stdout, "%d ", Cats->cat[j]);
/* Loop through all lines */
for (k = 0; k < nelem; k++) {
elem = abs(Vect_get_node_line(In, node, k));
type = Vect_read_line(In, NULL, Cats2, elem);
if (!(type & GV_LINES))
continue;
/* Loop through all cats of line */
for (l = 0; l < Cats2->n_cats; l++) {
if (Cats2->field[l] == afield) {
if (count > 0)
fprintf(stdout, ",");
fprintf(stdout, "%d", Cats2->cat[l]);
count++;
}
}
}
fprintf(stdout, "\n");
}
}
}
}
}
return 0;
}
