/**
\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)
{
struct bound_box bbox;
struct boxlist *List_tmp;
List_tmp = Vect_new_boxlist(0);
/* 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) */
merge_lists2(List, List_tmp);
Vect_destroy_boxlist(List_tmp);
return List->n_values;
}
/*!
\brief (Re)Attach isles in given bounding box to areas
The warning for Vect_attach_centroids() applies here as well
\param Map vector map
\param box bounding box
\return 0
*/
int Vect_attach_isles(struct Map_info *Map, const struct bound_box *box)
{
int i, isle, area;
struct bound_box abox;
static struct boxlist *List = NULL;
struct Plus_head *plus;
G_debug(3, "Vect_attach_isles()");
plus = &(Map->plus);
if (!List)
List = Vect_new_boxlist(TRUE);
Vect_select_isles_by_box(Map, box, List);
G_debug(3, " number of isles to attach = %d", List->n_values);
for (i = 0; i < List->n_values; i++) {
isle = List->id[i];
area = plus->Isle[isle]->area;
if (area > 0) {
/* if the area box is not fully inside the box, detach
* this might detach more than needed,
* but all that need to be reattached and
* is faster than reattaching all */
Vect_get_area_box(Map, area, &abox);
if (box->W < abox.W && box->E > abox.E &&
box->S < abox.S && box->N > abox.N) {
G_debug(3, "Outer area is fully inside search box");
}
else {
dig_area_del_isle(plus, area, isle);
plus->Isle[isle]->area = 0;
area = 0;
}
}
if (area == 0)
Vect_attach_isle(Map, isle, &List->box[i]);
}
return 0;
}
/*!
\brief (Re)Attach centroids in given bounding box to areas
Warning: If map is updated on level2, it may happen that
previously correct island becomes incorrect. In that case,
centroid of area forming the island is reattached to outer area,
because island polygon is not excluded.
<pre>
+-----------+ +-----------+
| 1 | | 1 |
| +---+---+ | | +---+---+ |
| | 2 | 3 | | | | 2 | |
| | x | | | -> | | x | |
| | | | | | | | |
| +---+---+ | | +---+---+ |
| | | |
+-----------+ +-----------+
centroid is centroid is
attached to 2 reattached to 1
</pre>
Because of this, when the centroid is reattached to another area,
it is always necessary to check if original area exist, unregister
centroid from previous area. To simplify code, this is
implemented so that centroid is always first unregistered and if
new area is found, it is registered again.
\param Map vector map
\param box bounding box
\return 0
*/
int Vect_attach_centroids(struct Map_info *Map, const struct bound_box * box)
{
int i, area, centr;
static int first = 1;
struct bound_box abox;
static struct boxlist *List;
struct P_area *Area;
struct P_line *Line;
struct P_topo_c *topo;
struct Plus_head *plus;
G_debug(3, "Vect_attach_centroids()");
plus = &(Map->plus);
if (first) {
List = Vect_new_boxlist(1);
first = 0;
}
Vect_select_lines_by_box(Map, box, GV_CENTROID, List);
G_debug(3, "\tnumber of centroids to reattach = %d", List->n_values);
for (i = 0; i < List->n_values; i++) {
centr = List->id[i];
Line = plus->Line[centr];
topo = (struct P_topo_c *)Line->topo;
area = topo->area;
if (area > 0) {
/* if the area box is not fully inside the box, detach
* this might detach more than needed,
* but all that need to be reattached and
* is faster than reattaching all */
Vect_get_area_box(Map, area, &abox);
if (box->W < abox.W && box->E > abox.E &&
box->S < abox.S && box->N > abox.N) {
G_debug(3, "Centroid's area is fully inside search box");
}
else {
Area = plus->Area[area];
Area->centroid = 0;
topo->area = 0;
area = 0;
}
}
if (area > 0) {
continue;
}
area = Vect_find_area(Map, List->box[i].E, List->box[i].N);
G_debug(3, "\tcentroid %d is in area %d", centr, area);
if (area > 0) {
Area = plus->Area[area];
if (Area->centroid == 0) { /* first centroid */
G_debug(3, "\tfirst centroid -> attach to area");
Area->centroid = centr;
topo->area = area;
}
else if (Area->centroid != centr) { /* duplicate centroid */
/* Note: it cannot happen that Area->centroid == centr, because the centroid
* was not registered or a duplicate */
G_debug(3, "\tduplicate centroid -> do not attach to area");
topo->area = -area;
}
}
}
return 0;
}
/*!
\brief Find area outside island
\param Map vector map
\param isle isle id
\param box isle bbox
\return area id
\return 0 if not found
*/
int Vect_isle_find_area(struct Map_info *Map, int isle, const struct bound_box *box)
{
int i, j, line, sel_area, area, poly;
const struct Plus_head *plus;
struct P_line *Line;
struct P_node *Node;
struct P_isle *Isle;
struct P_area *Area;
struct P_topo_b *topo;
struct bound_box *abox, nbox;
static struct boxlist *List = NULL;
static BOX_SIZE *size_list;
static int alloc_size_list = 0;
/* see also Vect_find_area() */
/* Note: We should check all isle points (at least) because if topology is not clean
* and two areas overlap, isle which is not completely within area may be attached,
* but it would take long time */
G_debug(3, "Vect_isle_find_area () island = %d", isle);
plus = &(Map->plus);
if (plus->Isle[isle] == NULL) {
G_warning(_("Request to find area outside nonexistent isle"));
return 0;
}
if (!List) {
List = Vect_new_boxlist(1);
alloc_size_list = 10;
size_list = G_malloc(alloc_size_list * sizeof(BOX_SIZE));
}
Isle = plus->Isle[isle];
line = abs(Isle->lines[0]);
Line = plus->Line[line];
topo = (struct P_topo_b *)Line->topo;
Node = plus->Node[topo->N1];
/* select areas by box */
nbox.E = Node->x;
nbox.W = Node->x;
nbox.N = Node->y;
nbox.S = Node->y;
nbox.T = PORT_DOUBLE_MAX;
nbox.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(Map, &nbox, List);
G_debug(3, "%d areas overlap island boundary point", List->n_values);
/* sort areas by bbox size
* get the smallest area that contains the isle
* using the bbox size is working because if 2 areas both contain
* the isle, one of these areas must be inside the other area
* which means that the bbox of the outer area must be larger than
* the bbox of the inner area, and equal bbox sizes are not possible */
if (alloc_size_list < List->n_values) {
alloc_size_list = List->n_values;
size_list = G_realloc(size_list, alloc_size_list * sizeof(BOX_SIZE));
}
j = 0;
for (i = 0; i < List->n_values; i++) {
abox = &List->box[i];
if (box->E > abox->E || box->W < abox->W || box->N > abox->N ||
box->S < abox->S) {
G_debug(3, " isle not completely inside area box");
continue;
}
List->id[j] = List->id[i];
List->box[j] = List->box[i];
size_list[j].i = List->id[j];
size_list[j].box = List->box[j];
size_list[j].size = (abox->N - abox->S) * (abox->E - abox->W);
j++;
}
List->n_values = j;
if (List->n_values > 1) {
if (List->n_values == 2) {
/* simple swap */
if (size_list[1].size < size_list[0].size) {
size_list[0].i = List->id[1];
size_list[1].i = List->id[0];
size_list[0].box = List->box[1];
size_list[1].box = List->box[0];
}
}
else
qsort(size_list, List->n_values, sizeof(BOX_SIZE), sort_by_size);
}
sel_area = 0;
for (i = 0; i < List->n_values; i++) {
area = size_list[i].i;
G_debug(3, "area = %d", area);
Area = plus->Area[area];
/* Before other tests, simply exclude those areas inside isolated isles formed by one boundary */
if (abs(Isle->lines[0]) == abs(Area->lines[0])) {
G_debug(3, " area inside isolated isle");
continue;
}
/* Check box */
/* Note: If build is run on large files of areas imported from nontopo format (shapefile)
* attaching of isles takes very long time because each area is also isle and select by
* box all overlapping areas selects all areas with box overlapping first node.
* Then reading coordinates for all those areas would take a long time -> check first
* if isle's box is completely within area box */
abox = &size_list[i].box;
if (box->E > abox->E || box->W < abox->W || box->N > abox->N ||
box->S < abox->S) {
G_debug(3, " isle not completely inside area box");
continue;
}
poly = Vect_point_in_area_outer_ring(Node->x, Node->y, Map, area, abox);
G_debug(3, " poly = %d", poly);
if (poly == 1) { /* point in area, but node is not part of area inside isle (would be poly == 2) */
#if 1
/* new version */
/* the bounding box of the smaller area is
* 1) inside the bounding box of a larger area and thus
* 2) smaller than the bounding box of a larger area */
sel_area = area;
break;
#else
/* old version */
/* In rare case island is inside more areas in that case we have to calculate area
* of outer ring and take the smaller */
if (sel_area == 0) { /* first */
sel_area = area;
}
else { /* is not first */
G_debug(1, "slow version of Vect_isle_find_area()");
if (cur_size < 0) { /* second area */
/* This is slow, but should not be called often */
Vect_get_area_points(Map, sel_area, APoints);
/* G_begin_polygon_area_calculations();
cur_size =
G_area_of_polygon(APoints->x, APoints->y,
APoints->n_points); */
/* this is faster, but there may be latlon problems: the poles */
dig_find_area_poly(APoints, &cur_size);
G_debug(3, " first area size = %f (n points = %d)",
cur_size, APoints->n_points);
}
Vect_get_area_points(Map, area, APoints);
/* size =
G_area_of_polygon(APoints->x, APoints->y,
APoints->n_points); */
/* this is faster, but there may be latlon problems: the poles */
dig_find_area_poly(APoints, &size);
G_debug(3, " area size = %f (n points = %d)", size,
APoints->n_points);
if (size > 0 && size < cur_size) {
sel_area = area;
cur_size = size;
/* this can not happen because the first area must be
* inside the second area because the node
* is inside both areas */
G_warning(_("Larger bbox but smaller area!!!"));
}
}
G_debug(3, "sel_area = %d cur_size = %f", sel_area, cur_size);
#endif
}
}
if (sel_area > 0) {
G_debug(3, "Island %d in area %d", isle, sel_area);
}
else {
G_debug(3, "Island %d is not in area", isle);
}
return sel_area;
}
int display_label(struct Map_info *Map, int type,
struct cat_list *Clist, LATTR *lattr, int chcat)
{
int ltype;
struct line_pnts *Points;
struct line_cats *Cats;
int ogr_centroids;
const struct Format_info *finfo;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_rewind(Map);
ogr_centroids = FALSE;
finfo = Vect_get_finfo(Map);
if (Vect_maptype(Map) == GV_FORMAT_OGR ||
(Vect_maptype(Map) == GV_FORMAT_POSTGIS &&
finfo->pg.toposchema_name == NULL)) {
if (Vect_level(Map) < 2)
G_warning(_("Topology level required for drawing centroids "
"for OGR layers"));
else if (Vect_get_num_primitives(Map, GV_CENTROID) > 0 &&
type & GV_CENTROID)
/* label centroids from topo, don't label boundaries */
ogr_centroids = TRUE;
}
while (TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
else if (ltype == -2) /* EOF */
break;
if (!(type & ltype) && !((type & GV_AREA) && (ltype & GV_CENTROID)))
continue; /* used for both lines and labels */
if (ogr_centroids && ltype == GV_BOUNDARY)
/* do not label boundaries */
continue;
process_line(ltype, Points, Cats, lattr, chcat, Clist);
}
if (ogr_centroids) {
/* show label for centroids stored in topo (for OGR layers
only) */
int line, nlines;
struct bound_box box;
struct boxlist *list;
list = Vect_new_boxlist(FALSE); /* bboxes not needed */
Vect_get_constraint_box(Map, &box);
nlines = Vect_select_lines_by_box(Map, &box, GV_CENTROID, list);
G_debug(3, "ncentroids (ogr) = %d", nlines);
for (line = 0; line < nlines; line++) {
ltype = Vect_read_line(Map, Points, Cats, list->id[line]);
process_line(ltype, Points, Cats, lattr, chcat, Clist);
}
Vect_destroy_boxlist(list);
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
char *p;
int i, j, k;
int method, half, use_catno;
const char *mapset;
struct GModule *module;
struct Option *point_opt, /* point vector */
*area_opt, /* area vector */
*point_type_opt, /* point type */
*point_field_opt, /* point layer */
*area_field_opt, /* area layer */
*method_opt, /* stats method */
*point_column_opt, /* point column for stats */
*count_column_opt, /* area column for point count */
*stats_column_opt, /* area column for stats result */
*fs_opt; /* field separator for printed output */
struct Flag *print_flag;
char *fs;
struct Map_info PIn, AIn;
int point_type, point_field, area_field;
struct line_pnts *Points;
struct line_cats *ACats, *PCats;
AREA_CAT *Area_cat;
int pline, ptype, count;
int area, nareas, nacats, nacatsalloc;
int ctype, nrec;
struct field_info *PFi, *AFi;
dbString stmt;
dbDriver *Pdriver, *Adriver;
char buf[2000];
int update_ok, update_err;
struct boxlist *List;
struct bound_box box;
dbCatValArray cvarr;
dbColumn *column;
struct pvalcat
{
double dval;
int catno;
} *pvalcats;
int npvalcats, npvalcatsalloc;
stat_func *statsvalue = NULL;
double result;
column = NULL;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("database"));
G_add_keyword(_("univariate statistics"));
G_add_keyword(_("zonal statistics"));
module->description = _("Count points in areas, calculate statistics from point attributes.");
point_opt = G_define_standard_option(G_OPT_V_INPUT);
point_opt->key = "points";
point_opt->description = _("Name of existing vector map with points");
/* point_opt->guisection = _("Required"); */
area_opt = G_define_standard_option(G_OPT_V_INPUT);
area_opt->key = "areas";
area_opt->description = _("Name of existing vector map with areas");
/* area_opt->guisection = _("Required"); */
point_type_opt = G_define_standard_option(G_OPT_V_TYPE);
point_type_opt->key = "type";
point_type_opt->options = "point,centroid";
point_type_opt->answer = "point";
point_type_opt->label = _("Feature type");
point_type_opt->required = NO;
point_field_opt = G_define_standard_option(G_OPT_V_FIELD);
point_field_opt->key = "player";
point_field_opt->label = _("Layer number for points map");
area_field_opt = G_define_standard_option(G_OPT_V_FIELD);
area_field_opt->key = "alayer";
area_field_opt->label = _("Layer number for area map");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = NO;
method_opt->multiple = NO;
p = G_malloc(1024);
for (i = 0; menu[i].name; i++) {
if (i)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[i].name);
}
method_opt->options = p;
method_opt->description = _("Method for aggregate statistics");
point_column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
point_column_opt->key = "pcolumn";
point_column_opt->required = NO;
point_column_opt->multiple = NO;
point_column_opt->label =
_("Column name of points map to use for statistics");
point_column_opt->description = _("Column of points map must be numeric");
count_column_opt = G_define_option();
count_column_opt->key = "ccolumn";
count_column_opt->type = TYPE_STRING;
count_column_opt->required = NO;
count_column_opt->multiple = NO;
count_column_opt->label = _("Column name to upload points count");
count_column_opt->description =
_("Column to hold points count, must be of type integer, will be created if not existing");
stats_column_opt = G_define_option();
stats_column_opt->key = "scolumn";
stats_column_opt->type = TYPE_STRING;
stats_column_opt->required = NO;
stats_column_opt->multiple = NO;
stats_column_opt->label = _("Column name to upload statistics");
stats_column_opt->description =
_("Column to hold statistics, must be of type double, will be created if not existing");
fs_opt = G_define_standard_option(G_OPT_F_SEP);
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->label =
_("Print output to stdout, do not update attribute table");
print_flag->description = _("First column is always area category");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
point_type = Vect_option_to_types(point_type_opt);
point_field = atoi(point_field_opt->answer);
area_field = atoi(area_field_opt->answer);
if (print_flag->answer)
/* get field separator */
fs = G_option_to_separator(fs_opt);
else
fs = NULL;
/* check for stats */
if (method_opt->answer) {
if (!point_column_opt->answer) {
G_fatal_error("Method but no point column selected");
}
if (!print_flag->answer && !stats_column_opt->answer)
G_fatal_error("Name for stats column is missing");
}
if (point_column_opt->answer) {
if (!method_opt->answer)
G_fatal_error("No method for statistics selected");
if (!print_flag->answer && !stats_column_opt->answer)
G_fatal_error("Name for stats column is missing");
}
/* Open points vector */
if ((mapset = G_find_vector2(point_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), point_opt->answer);
Vect_set_open_level(2);
if (Vect_open_old(&PIn, point_opt->answer, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), point_opt->answer);
/* Open areas vector */
if ((mapset = G_find_vector2(area_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), area_opt->answer);
if (!print_flag->answer && strcmp(mapset, G_mapset()) != 0)
G_fatal_error(_("Vector map <%s> is not in user mapset and cannot be updated"),
area_opt->answer);
Vect_set_open_level(2);
if (Vect_open_old(&AIn, area_opt->answer, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), area_opt->answer);
method = -1;
use_catno = 0;
half = 0;
if (method_opt->answer) {
/* get the method */
for (method = 0; (p = menu[method].name); method++)
if ((strcmp(p, method_opt->answer) == 0))
break;
if (!p) {
G_warning(_("<%s=%s> unknown %s"),
method_opt->key, method_opt->answer,
method_opt->answer);
G_usage();
exit(EXIT_FAILURE);
}
/* establish the statsvalue routine */
statsvalue = menu[method].method;
/* category number of lowest/highest value */
if ((strcmp(menu[method].name, menu[5].name) == 0) ||
(strcmp(menu[method].name, menu[7].name) == 0))
use_catno = 1;
G_debug(1, "method: %s, use cat value: %s", menu[method].name,
(use_catno == 1 ? "yes" : "no"));
}
/* Open database driver */
db_init_string(&stmt);
Adriver = NULL;
if (!print_flag->answer) {
AFi = Vect_get_field(&AIn, area_field);
if (AFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
area_field);
Adriver = db_start_driver_open_database(AFi->driver, AFi->database);
if (Adriver == NULL)
G_fatal_error(_("Unable to open database <%s> with driver <%s>"),
AFi->database, AFi->driver);
if (!count_column_opt->answer)
G_fatal_error(_("ccolumn is required to upload point counts"));
/* check if count column exists */
G_debug(1, "check if count column exists");
db_get_column(Adriver, AFi->table, count_column_opt->answer, &column);
if (column) {
/* check count column type */
if (db_column_Ctype(Adriver, AFi->table, count_column_opt->answer)
!= DB_C_TYPE_INT)
G_fatal_error(_("ccolumn must be of type integer"));
db_free_column(column);
column = NULL;
}
else {
/* create count column */
/* db_add_column() exists but is not implemented,
* see lib/db/stubs/add_col.c */
sprintf(buf, "alter table %s add column %s integer",
AFi->table, count_column_opt->answer);
db_set_string(&stmt, buf);
if (db_execute_immediate(Adriver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s>"),
count_column_opt->answer);
}
if (method_opt->answer) {
if (!stats_column_opt->answer)
G_fatal_error(_("scolumn is required to upload point stats"));
/* check if stats column exists */
G_debug(1, "check if stats column exists");
db_get_column(Adriver, AFi->table, stats_column_opt->answer,
&column);
if (column) {
/* check stats column type */
if (db_column_Ctype
(Adriver, AFi->table,
stats_column_opt->answer) != DB_C_TYPE_DOUBLE)
G_fatal_error(_("scolumn must be of type double"));
db_free_column(column);
column = NULL;
}
else {
/* create stats column */
/* db_add_column() exists but is not implemented,
* see lib/db/stubs/add_col.c */
sprintf(buf, "alter table %s add column %s double",
AFi->table, stats_column_opt->answer);
db_set_string(&stmt, buf);
if (db_execute_immediate(Adriver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s>"),
stats_column_opt->answer);
}
}
}
else
AFi = NULL;
Pdriver = NULL;
if (method_opt->answer) {
G_verbose_message(_("collecting attributes from points vector..."));
PFi = Vect_get_field(&PIn, point_field);
if (PFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
point_field);
Pdriver = db_start_driver_open_database(PFi->driver, PFi->database);
if (Pdriver == NULL)
G_fatal_error(_("Unable to open database <%s> with driver <%s>"),
PFi->database, PFi->driver);
/* check if point column exists */
db_get_column(Pdriver, PFi->table, point_column_opt->answer, &column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
point_column_opt->answer, PFi->table);
}
/* Check column type */
ctype =
db_column_Ctype(Pdriver, PFi->table, point_column_opt->answer);
if (ctype == DB_C_TYPE_INT)
half = menu[method].half;
else if (ctype == DB_C_TYPE_DOUBLE)
half = 0;
else
G_fatal_error(_("column for points vector must be numeric"));
db_CatValArray_init(&cvarr);
nrec = db_select_CatValArray(Pdriver, PFi->table, PFi->key,
point_column_opt->answer, NULL, &cvarr);
G_debug(1, "selected values = %d", nrec);
db_close_database_shutdown_driver(Pdriver);
}
Points = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
PCats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/* Allocate space ( may be more than needed (duplicate cats and elements without cats) ) */
if ((nareas = Vect_get_num_areas(&AIn)) <= 0)
G_fatal_error("No areas in area input vector");
nacatsalloc = nareas;
Area_cat = (AREA_CAT *) G_calloc(nacatsalloc, sizeof(AREA_CAT));
/* Read all cats from 'area' */
nacats = 0;
for (area = 1; area <= nareas; area++) {
Vect_get_area_cats(&AIn, area, ACats);
if (ACats->n_cats <= 0)
continue;
for (i = 0; i < ACats->n_cats; i++) {
if (ACats->field[i] == area_field) {
Area_cat[nacats].area_cat = ACats->cat[i];
Area_cat[nacats].count = 0;
Area_cat[nacats].nvalues = 0;
Area_cat[nacats].nalloc = 0;
nacats++;
if (nacats >= nacatsalloc) {
nacatsalloc += 100;
Area_cat =
(AREA_CAT *) G_realloc(Area_cat,
nacatsalloc *
sizeof(AREA_CAT));
}
}
}
}
G_debug(1, "%d cats loaded from vector (including duplicates)", nacats);
/* Sort by category */
qsort((void *)Area_cat, nacats, sizeof(AREA_CAT), cmp_area);
/* remove duplicate categories */
for (i = 1; i < nacats; i++) {
if (Area_cat[i].area_cat == Area_cat[i - 1].area_cat) {
for (j = i; j < nacats - 1; j++) {
Area_cat[j].area_cat = Area_cat[j + 1].area_cat;
}
nacats--;
}
}
G_debug(1, "%d cats loaded from vector (unique)", nacats);
/* Go through all areas in area vector and find points in points vector
* falling into the area */
npvalcatsalloc = 10;
npvalcats = 0;
pvalcats =
(struct pvalcat *)G_calloc(npvalcatsalloc, sizeof(struct pvalcat));
G_message(_("Selecting points for each area..."));
count = 0;
for (area = 1; area <= nareas; area++) {
dbCatVal *catval;
G_debug(3, "area = %d", area);
G_percent(area, nareas, 2);
Vect_get_area_cats(&AIn, area, ACats);
if (ACats->n_cats <= 0)
continue;
/* select points by box */
Vect_get_area_box(&AIn, area, &box);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&PIn, &box, point_type, List);
G_debug(4, "%d points selected by box", List->n_values);
/* For each point in box check if it is in the area */
for (i = 0; i < List->n_values; i++) {
pline = List->id[i];
G_debug(4, "%d: point %d", i, pline);
ptype = Vect_read_line(&PIn, Points, PCats, pline);
if (!(ptype & point_type))
continue;
/* point in area */
if (Vect_point_in_area(Points->x[0], Points->y[0], &AIn, area, &box)) {
AREA_CAT *area_info, search_ai;
int tmp_cat;
/* stats on point column */
if (method_opt->answer) {
npvalcats = 0;
tmp_cat = -1;
for (j = 0; j < PCats->n_cats; j++) {
if (PCats->field[j] == point_field) {
if (tmp_cat >= 0)
G_debug(3,
"More cats found in point layer (point=%d)",
pline);
tmp_cat = PCats->cat[j];
/* find cat in array */
db_CatValArray_get_value(&cvarr, tmp_cat,
&catval);
if (catval) {
pvalcats[npvalcats].catno = tmp_cat;
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
pvalcats[npvalcats].dval = catval->val.i;
npvalcats++;
break;
case DB_C_TYPE_DOUBLE:
pvalcats[npvalcats].dval = catval->val.d;
npvalcats++;
break;
}
if (npvalcats >= npvalcatsalloc) {
npvalcatsalloc += 10;
pvalcats =
(struct pvalcat *)G_realloc(pvalcats,
npvalcatsalloc
*
sizeof
(struct
pvalcat));
}
}
}
}
}
/* update count for all area cats of given field */
search_ai.area_cat = -1;
for (j = 0; j < ACats->n_cats; j++) {
if (ACats->field[j] == area_field) {
if (search_ai.area_cat >= 0)
G_debug(3,
"More cats found in area layer (area=%d)",
area);
search_ai.area_cat = ACats->cat[j];
/* find cat in array */
area_info =
(AREA_CAT *) bsearch((void *)&search_ai, Area_cat,
nacats, sizeof(AREA_CAT),
cmp_area);
if (area_info->area_cat != search_ai.area_cat)
G_fatal_error(_("could not find area category %d"),
search_ai.area_cat);
/* each point is counted once, also if it has
* more than one category or no category
* OK? */
area_info->count++;
if (method_opt->answer) {
/* ensure enough space */
if (area_info->nvalues + npvalcats >=
area_info->nalloc) {
if (area_info->nalloc == 0) {
area_info->nalloc = npvalcats + 10;
area_info->values =
(double *)G_calloc(area_info->nalloc,
sizeof(double));
area_info->cats =
(int *)G_calloc(area_info->nalloc,
sizeof(int));
}
else
area_info->nalloc +=
area_info->nvalues + npvalcats + 10;
area_info->values =
(double *)G_realloc(area_info->values,
area_info->nalloc *
sizeof(double));
area_info->cats =
(int *)G_realloc(area_info->cats,
area_info->nalloc *
sizeof(int));
}
for (k = 0; k < npvalcats; k++) {
area_info->cats[area_info->nvalues] =
pvalcats[k].catno;
area_info->values[area_info->nvalues] =
pvalcats[k].dval;
area_info->nvalues++;
}
}
}
}
count++;
}
} /* next point in box */
} /* next area */
G_debug(1, "count = %d", count);
/* release catval array */
if (method_opt->answer)
db_CatValArray_free(&cvarr);
Vect_close(&PIn);
/* Update table or print to stdout */
if (print_flag->answer) { /* print header */
fprintf(stdout, "area_cat%scount", fs);
if (method_opt->answer)
fprintf(stdout, "%s%s", fs, menu[method].name);
fprintf(stdout, "\n");
}
else {
G_message("Updating attributes for area vector...");
update_err = update_ok = 0;
}
if (Adriver)
db_begin_transaction(Adriver);
for (i = 0; i < nacats; i++) {
if (!print_flag->answer)
G_percent(i, nacats, 2);
result = 0;
if (Area_cat[i].count > 0 && method_opt->answer) {
/* get stats */
statsvalue(&result, Area_cat[i].values, Area_cat[i].nvalues,
NULL);
if (half)
result += 0.5;
else if (use_catno)
result = Area_cat[i].cats[(int)result];
}
if (print_flag->answer) {
fprintf(stdout, "%d%s%d", Area_cat[i].area_cat, fs,
Area_cat[i].count);
if (method_opt->answer) {
if (Area_cat[i].count > 0)
fprintf(stdout, "%s%.15g", fs, result);
else
fprintf(stdout, "%snull", fs);
}
fprintf(stdout, "\n");
}
else {
sprintf(buf, "update %s set %s = %d", AFi->table,
count_column_opt->answer, Area_cat[i].count);
db_set_string(&stmt, buf);
if (method_opt->answer) {
if (Area_cat[i].count > 0)
sprintf(buf, " , %s = %.15g", stats_column_opt->answer,
result);
else
sprintf(buf, " , %s = null", stats_column_opt->answer);
db_append_string(&stmt, buf);
}
sprintf(buf, " where %s = %d", AFi->key, Area_cat[i].area_cat);
db_append_string(&stmt, buf);
G_debug(2, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(Adriver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
}
if (Adriver)
db_commit_transaction(Adriver);
if (!print_flag->answer) {
G_percent(nacats, nacats, 2);
db_close_database_shutdown_driver(Adriver);
db_free_string(&stmt);
G_message(_("%d records updated"), update_ok);
if (update_err > 0)
G_message(_("%d update errors"), update_err);
Vect_set_db_updated(&AIn);
}
Vect_close(&AIn);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
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;
}
/*!
\brief Remove duplicate features from vector map.
Remove duplicate lines of given types from vector map. Duplicate
lines may be optionally written to error map. Input map must be
opened on level 2 for update. Categories are merged.
GV_BUILD_BASE is sufficient.
\param[in,out] Map vector map where duplicate lines will be deleted
\param type type of line to be delete
\param[out] Err vector map where duplicate lines will be written or NULL
\return void
*/
void
Vect_remove_duplicates(struct Map_info *Map, int type, struct Map_info *Err)
{
struct line_pnts *APoints, *BPoints;
struct line_cats *ACats, *BCats, *Cats;
int i, j, c, atype, btype, bline;
int nlines, nbcats_orig;
struct bound_box ABox;
struct boxlist *List;
int ndupl;
APoints = Vect_new_line_struct();
BPoints = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
nlines = Vect_get_num_lines(Map);
G_debug(1, "nlines = %d", nlines);
/* Go through all lines in vector, for each select lines which overlap MBR of
* this line and check if some of them is identical. If someone is identical
* remove current line. (In each step just one line is deleted)
*/
ndupl = 0;
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
if (!Vect_line_alive(Map, i))
continue;
atype = Vect_read_line(Map, APoints, ACats, i);
if (!(atype & type))
continue;
Vect_line_box(APoints, &ABox);
Vect_select_lines_by_box(Map, &ABox, type, List);
G_debug(3, " %d lines selected by box", List->n_values);
for (j = 0; j < List->n_values; j++) {
bline = List->id[j];
G_debug(3, " j = %d bline = %d", j, bline);
if (i == bline)
continue;
btype = Vect_read_line(Map, BPoints, BCats, bline);
/* check for duplicates */
if (!Vect_line_check_duplicate(APoints, BPoints, Vect_is_3d(Map)))
continue;
/* Lines area identical -> remove current */
if (Err) {
Vect_write_line(Err, atype, APoints, ACats);
}
Vect_delete_line(Map, i);
/* Merge categories */
nbcats_orig = BCats->n_cats;
for (c = 0; c < ACats->n_cats; c++)
Vect_cat_set(BCats, ACats->field[c], ACats->cat[c]);
if (BCats->n_cats > nbcats_orig) {
G_debug(4, "cats merged: n_cats %d -> %d", nbcats_orig,
BCats->n_cats);
Vect_rewrite_line(Map, bline, btype, BPoints, BCats);
}
ndupl++;
break; /* line was deleted -> take the next one */
}
nlines = Vect_get_num_lines(Map); /* For future when lines with cats will be rewritten */
G_debug(3, "nlines = %d\n", nlines);
}
G_verbose_message("Removed duplicates: %d", ndupl);
}
/* check topology corruption by boundary modification
* return 0 on corruption, 1 if modification is ok */
int check_topo(struct Map_info *Out, int line, struct line_pnts *APoints,
struct line_pnts *Points, struct line_cats *Cats)
{
int i, j, intersect, newline, left_old, right_old,
left_new, right_new;
struct bound_box box;
struct line_pnts **AXLines, **BXLines;
int naxlines, nbxlines;
static struct line_pnts *BPoints = NULL;
static struct boxlist *List = NULL;
if (!BPoints)
BPoints = Vect_new_line_struct();
if (!List)
List = Vect_new_boxlist(1);
Vect_line_box(Points, &box);
/* Check the modified boundary for self-intersection */
AXLines = BXLines = NULL;
Vect_line_intersection2(Points, NULL, &box, &box, &AXLines, &BXLines,
&naxlines, &nbxlines, 0);
/* Free */
if (naxlines > 0) {
for (j = 0; j < naxlines; j++) {
Vect_destroy_line_struct(AXLines[j]);
}
}
if (AXLines)
G_free(AXLines);
if (naxlines > 0)
return 0;
/* Check intersection of the modified boundary with other boundaries */
Vect_select_lines_by_box(Out, &box, GV_BOUNDARY, List);
intersect = 0;
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->id[i];
if (bline == line)
continue;
Vect_read_line(Out, BPoints, NULL, bline);
/* Vect_line_intersection is quite slow, hopefully not so bad because only few
* intersections should be found if any */
AXLines = BXLines = NULL;
Vect_line_intersection2(Points, BPoints, &box, &List->box[i],
&AXLines, &BXLines,
&naxlines, &nbxlines, 0);
G_debug(4,
"bline = %d intersect = %d naxlines = %d nbxlines = %d",
bline, intersect, naxlines, nbxlines);
/* Free */
if (naxlines > 0) {
for (j = 0; j < naxlines; j++) {
Vect_destroy_line_struct(AXLines[j]);
}
}
if (AXLines)
G_free(AXLines);
if (nbxlines > 0) {
for (j = 0; j < nbxlines; j++) {
Vect_destroy_line_struct(BXLines[j]);
}
}
if (BXLines)
G_free(BXLines);
if (naxlines > 1 || nbxlines > 1) {
intersect = 1;
break;
}
}
/* modified boundary intersects another boundary */
if (intersect)
return 0;
/* Get centroids on the left and right side */
Vect_get_line_areas(Out, line, &left_old, &right_old);
if (left_old < 0)
left_old = Vect_get_isle_area(Out, abs(left_old));
if (left_old > 0)
left_old = Vect_get_area_centroid(Out, left_old);
if (right_old < 0)
right_old = Vect_get_isle_area(Out, abs(right_old));
if (right_old > 0)
right_old = Vect_get_area_centroid(Out, right_old);
/* OK, rewrite modified boundary */
newline = Vect_rewrite_line(Out, line, GV_BOUNDARY, Points, Cats);
/* Check position of centroids */
Vect_get_line_areas(Out, newline, &left_new, &right_new);
if (left_new < 0)
left_new = Vect_get_isle_area(Out, abs(left_new));
if (left_new > 0)
left_new = Vect_get_area_centroid(Out, left_new);
if (right_new < 0)
right_new = Vect_get_isle_area(Out, abs(right_new));
if (right_new > 0)
right_new = Vect_get_area_centroid(Out, right_new);
if (left_new != left_old || right_new != right_old) {
G_debug(3,
"The modified boundary changes attachment of centroid -> not modified");
Vect_rewrite_line(Out, newline, GV_BOUNDARY, APoints, Cats);
return 0;
}
return 1;
}
int 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 main(int argc, char *argv[])
{
char *output, buf[DB_SQL_MAX];
double (*rng)(void) = G_drand48;
double zmin, zmax;
int seed;
int i, j, k, n, type, usefloat;
int area, nareas, field;
struct boxlist *List = NULL;
BOX_SIZE *size_list = NULL;
int alloc_size_list = 0;
struct Map_info In, Out;
struct line_pnts *Points;
struct line_cats *Cats;
struct cat_list *cat_list;
struct bound_box box;
struct Cell_head window;
struct GModule *module;
struct
{
struct Option *input, *field, *cats, *where, *output, *nsites,
*zmin, *zmax, *zcol, *ztype, *seed;
} parm;
struct
{
struct Flag *z, *notopo, *a;
} flag;
struct field_info *Fi;
dbDriver *driver;
dbTable *table;
dbString sql;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("sampling"));
G_add_keyword(_("statistics"));
G_add_keyword(_("random"));
module->description = _("Generates random 2D/3D vector points.");
parm.output = G_define_standard_option(G_OPT_V_OUTPUT);
parm.nsites = G_define_option();
parm.nsites->key = "n";
parm.nsites->type = TYPE_INTEGER;
parm.nsites->required = YES;
parm.nsites->description = _("Number of points to be created");
parm.input = G_define_standard_option(G_OPT_V_INPUT);
parm.input->required = NO;
parm.input->description = _("Restrict points to areas in input vector");
parm.input->guisection = _("Selection");
parm.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
parm.field->guisection = _("Selection");
parm.cats = G_define_standard_option(G_OPT_V_CATS);
parm.cats->guisection = _("Selection");
parm.where = G_define_standard_option(G_OPT_DB_WHERE);
parm.where->guisection = _("Selection");
parm.zmin = G_define_option();
parm.zmin->key = "zmin";
parm.zmin->type = TYPE_DOUBLE;
parm.zmin->required = NO;
parm.zmin->description =
_("Minimum z height (needs -z flag or column name)");
parm.zmin->answer = "0.0";
parm.zmin->guisection = _("3D output");
parm.zmax = G_define_option();
parm.zmax->key = "zmax";
parm.zmax->type = TYPE_DOUBLE;
parm.zmax->required = NO;
parm.zmax->description =
_("Maximum z height (needs -z flag or column name)");
parm.zmax->answer = "0.0";
parm.zmax->guisection = _("3D output");
parm.seed = G_define_option();
parm.seed->key = "seed";
parm.seed->type = TYPE_INTEGER;
parm.seed->required = NO;
parm.seed->description =
_("The seed to initialize the random generator. If not set the process ID is used");
parm.zcol = G_define_standard_option(G_OPT_DB_COLUMN);
parm.zcol->label = _("Name of column for z values");
parm.zcol->description =
_("Writes z values to column");
parm.zcol->guisection = _("3D output");
parm.ztype = G_define_option();
parm.ztype->key = "column_type";
parm.ztype->type = TYPE_STRING;
parm.ztype->required = NO;
parm.ztype->multiple = NO;
parm.ztype->description = _("Type of column for z values");
parm.ztype->options = "integer,double precision";
parm.ztype->answer = "double precision";
parm.ztype->guisection = _("3D output");
flag.z = G_define_flag();
flag.z->key = 'z';
flag.z->description = _("Create 3D output");
flag.z->guisection = _("3D output");
flag.a = G_define_flag();
flag.a->key = 'a';
flag.a->description = _("Generate n points for each individual area");
flag.notopo = G_define_standard_flag(G_FLG_V_TOPO);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
output = parm.output->answer;
n = atoi(parm.nsites->answer);
if(parm.seed->answer)
seed = atoi(parm.seed->answer);
if (n <= 0) {
G_fatal_error(_("Number of points must be > 0 (%d given)"), n);
}
nareas = 0;
cat_list = NULL;
field = -1;
if (parm.input->answer) {
Vect_set_open_level(2); /* topology required */
if (2 > Vect_open_old2(&In, parm.input->answer, "", parm.field->answer))
G_fatal_error(_("Unable to open vector map <%s>"),
parm.input->answer);
if (parm.field->answer)
field = Vect_get_field_number(&In, parm.field->answer);
if ((parm.cats->answer || parm.where->answer) && field == -1) {
G_warning(_("Invalid layer number (%d). Parameter '%s' or '%s' specified, assuming layer '1'."),
field, parm.cats->key, parm.where->key);
field = 1;
}
if (field > 0)
cat_list = Vect_cats_set_constraint(&In, field, parm.where->answer,
parm.cats->answer);
nareas = Vect_get_num_areas(&In);
if (nareas == 0) {
Vect_close(&In);
G_fatal_error(_("No areas in vector map <%s>"), parm.input->answer);
}
}
else {
if (flag.a->answer)
G_fatal_error(_("The <-%c> flag requires an input vector with areas"),
flag.a->key);
}
/* create new vector map */
if (-1 == Vect_open_new(&Out, output, flag.z->answer ? WITH_Z : WITHOUT_Z))
G_fatal_error(_("Unable to create vector map <%s>"), output);
Vect_set_error_handler_io(NULL, &Out);
/* Do we need to write random values into attribute table? */
usefloat = -1;
if (parm.zcol->answer) {
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
driver =
db_start_driver_open_database(Fi->driver,
Vect_subst_var(Fi->database, &Out));
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, &Out), Fi->driver);
}
db_set_error_handler_driver(driver);
db_begin_transaction(driver);
db_init_string(&sql);
sprintf(buf, "create table %s (%s integer, %s %s)", Fi->table, GV_KEY_COLUMN,
parm.zcol->answer, parm.ztype->answer);
db_set_string(&sql, buf);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
/* Create table */
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to create table: %s"),
db_get_string(&sql));
}
/* Create index */
if (db_create_index2(driver, Fi->table, Fi->key) != DB_OK)
G_warning(_("Unable to create index"));
/* Grant */
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK) {
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
}
/* OK. Let's check what type of column user has created */
db_set_string(&sql, Fi->table);
if (db_describe_table(driver, &sql, &table) != DB_OK) {
G_fatal_error(_("Unable to describe table <%s>"), Fi->table);
}
if (db_get_table_number_of_columns(table) != 2) {
G_fatal_error(_("Table should contain only two columns"));
}
type = db_get_column_sqltype(db_get_table_column(table, 1));
if (type == DB_SQL_TYPE_SMALLINT || type == DB_SQL_TYPE_INTEGER)
usefloat = 0;
if (type == DB_SQL_TYPE_REAL || type == DB_SQL_TYPE_DOUBLE_PRECISION)
usefloat = 1;
if (usefloat < 0) {
G_fatal_error(_("You have created unsupported column type. This module supports only INTEGER"
" and DOUBLE PRECISION column types."));
}
}
Vect_hist_command(&Out);
/* Init the random seed */
if(parm.seed->answer)
G_srand48(seed);
else
G_srand48_auto();
G_get_window(&window);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (nareas > 0) {
int first = 1, count;
struct bound_box abox, bbox;
box.W = window.west;
box.E = window.east;
box.S = window.south;
box.N = window.north;
box.B = -PORT_DOUBLE_MAX;
box.T = PORT_DOUBLE_MAX;
count = 0;
for (i = 1; i <= nareas; i++) {
if (!Vect_get_area_centroid(&In, i))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, i, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list))
continue;
}
Vect_get_area_box(&In, i, &abox);
if (!Vect_box_overlap(&abox, &box))
continue;
if (first) {
Vect_box_copy(&bbox, &abox);
first = 0;
}
else
Vect_box_extend(&bbox, &abox);
count++;
}
if (count == 0) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(output);
G_fatal_error(_("Selected areas in input vector <%s> do not overlap with the current region"),
parm.input->answer);
}
Vect_box_copy(&box, &bbox);
/* does the vector overlap with the current region ? */
if (box.W >= window.east || box.E <= window.west ||
box.S >= window.north || box.N <= window.south) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(output);
G_fatal_error(_("Input vector <%s> does not overlap with the current region"),
parm.input->answer);
}
/* try to reduce the current region */
if (window.east > box.E)
window.east = box.E;
if (window.west < box.W)
window.west = box.W;
if (window.north > box.N)
window.north = box.N;
if (window.south < box.S)
window.south = box.S;
List = Vect_new_boxlist(1);
alloc_size_list = 10;
size_list = G_malloc(alloc_size_list * sizeof(BOX_SIZE));
}
zmin = zmax = 0;
if (flag.z->answer || parm.zcol->answer) {
zmax = atof(parm.zmax->answer);
zmin = atof(parm.zmin->answer);
}
G_message(_("Generating points..."));
if (flag.a->answer && nareas > 0) {
struct bound_box abox, bbox;
int cat = 1;
/* n points for each area */
nareas = Vect_get_num_areas(&In);
G_percent(0, nareas, 1);
for (area = 1; area <= nareas; area++) {
G_percent(area, nareas, 1);
if (!Vect_get_area_centroid(&In, area))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, area, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list)) {
continue;
}
}
box.W = window.west;
box.E = window.east;
box.S = window.south;
box.N = window.north;
box.B = -PORT_DOUBLE_MAX;
box.T = PORT_DOUBLE_MAX;
Vect_get_area_box(&In, area, &abox);
if (!Vect_box_overlap(&box, &abox))
continue;
bbox = abox;
if (bbox.W < box.W)
bbox.W = box.W;
if (bbox.E > box.E)
bbox.E = box.E;
if (bbox.S < box.S)
bbox.S = box.S;
if (bbox.N > box.N)
bbox.N = box.N;
for (i = 0; i < n; ++i) {
double x, y, z;
int outside = 1;
int ret;
Vect_reset_line(Points);
Vect_reset_cats(Cats);
while (outside) {
x = rng() * (bbox.W - bbox.E) + bbox.E;
y = rng() * (bbox.N - bbox.S) + bbox.S;
z = rng() * (zmax - zmin) + zmin;
ret = Vect_point_in_area(x, y, &In, area, &abox);
G_debug(3, " area = %d Vect_point_in_area() = %d", area, ret);
if (ret >= 1) {
outside = 0;
}
}
if (flag.z->answer)
Vect_append_point(Points, x, y, z);
else
Vect_append_point(Points, x, y, 0.0);
if (parm.zcol->answer) {
sprintf(buf, "insert into %s values ( %d, ", Fi->table, i + 1);
db_set_string(&sql, buf);
/* Round random value if column is integer type */
if (usefloat)
sprintf(buf, "%f )", z);
else
sprintf(buf, "%.0f )", z);
db_append_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
Vect_cat_set(Cats, 1, cat++);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
}
}
else {
/* n points in total */
for (i = 0; i < n; ++i) {
double x, y, z;
G_percent(i, n, 4);
Vect_reset_line(Points);
Vect_reset_cats(Cats);
x = rng() * (window.west - window.east) + window.east;
y = rng() * (window.north - window.south) + window.south;
z = rng() * (zmax - zmin) + zmin;
if (nareas) {
int outside = 1;
do {
/* select areas by box */
box.E = x;
box.W = x;
box.N = y;
box.S = y;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&In, &box, List);
G_debug(3, " %d areas selected by box", List->n_values);
/* sort areas by size, the smallest is likely to be the nearest */
if (alloc_size_list < List->n_values) {
alloc_size_list = List->n_values;
size_list = G_realloc(size_list, alloc_size_list * sizeof(BOX_SIZE));
}
k = 0;
for (j = 0; j < List->n_values; j++) {
area = List->id[j];
if (!Vect_get_area_centroid(&In, area))
continue;
if (field > 0) {
if (Vect_get_area_cats(&In, area, Cats))
continue;
if (!Vect_cats_in_constraint(Cats, field, cat_list)) {
continue;
}
}
List->id[k] = List->id[j];
List->box[k] = List->box[j];
size_list[k].i = List->id[k];
box = List->box[k];
size_list[k].box = List->box[k];
size_list[k].size = (box.N - box.S) * (box.E - box.W);
k++;
}
List->n_values = k;
if (List->n_values == 2) {
/* simple swap */
if (size_list[1].size < size_list[0].size) {
size_list[0].i = List->id[1];
size_list[1].i = List->id[0];
size_list[0].box = List->box[1];
size_list[1].box = List->box[0];
}
}
else if (List->n_values > 2)
qsort(size_list, List->n_values, sizeof(BOX_SIZE), sort_by_size);
for (j = 0; j < List->n_values; j++) {
int ret;
area = size_list[j].i;
ret = Vect_point_in_area(x, y, &In, area, &size_list[j].box);
G_debug(3, " area = %d Vect_point_in_area() = %d", area, ret);
if (ret >= 1) {
outside = 0;
break;
}
}
if (outside) {
x = rng() * (window.west - window.east) + window.east;
y = rng() * (window.north - window.south) + window.south;
z = rng() * (zmax - zmin) + zmin;
}
} while (outside);
}
if (flag.z->answer)
Vect_append_point(Points, x, y, z);
else
Vect_append_point(Points, x, y, 0.0);
if (parm.zcol->answer) {
sprintf(buf, "insert into %s values ( %d, ", Fi->table, i + 1);
db_set_string(&sql, buf);
/* Round random value if column is integer type */
if (usefloat)
sprintf(buf, "%f )", z);
else
sprintf(buf, "%.0f )", z);
db_append_string(&sql, buf);
G_debug(3, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new row: %s"),
db_get_string(&sql));
}
}
Vect_cat_set(Cats, 1, i + 1);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
G_percent(1, 1, 1);
}
if (parm.zcol->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
if (!flag.notopo->answer) {
Vect_build(&Out);
}
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int out_fd;
CELL *result, *rp;
int nrows, ncols;
int row, col, count_sum;
int field;
struct GModule *module;
struct Option *in_opt, *out_opt, *field_opt;
struct Option *method_opt, *size_opt;
struct Map_info In;
double radius;
struct boxlist *List;
struct Cell_head region;
struct bound_box box;
struct line_pnts *Points;
struct line_cats *Cats;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("algebra"));
G_add_keyword(_("statistics"));
G_add_keyword(_("raster"));
G_add_keyword(_("aggregation"));
module->label = _("Neighborhood analysis tool for vector point maps.");
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.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
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 */
Vect_set_open_level(2);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
field = Vect_get_field_number(&In, field_opt->answer);
G_get_set_window(®ion);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
result = Rast_allocate_buf(CELL_TYPE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/*open the new cellfile */
out_fd = Rast_open_new(out_opt->answer, CELL_TYPE);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
count_sum = 0;
for (row = 0; row < nrows; row++) {
double x, y;
G_percent(row, nrows, 2);
y = Rast_row_to_northing(row + 0.5, ®ion);
box.N = y + radius;
box.S = y - radius;
Rast_set_null_value(result, ncols, CELL_TYPE);
rp = result;
for (col = 0; col < ncols; col++) {
int i, count;
CELL value;
x = Rast_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++) {
Vect_read_line(&In, Points, Cats, List->id[i]);
if (field != -1 && Vect_cat_get(Cats, field, NULL) == 0)
continue;
if (Vect_points_distance(x, y, 0.0, Points->x[0],
Points->y[0], 0.0, 0) <= radius)
count++;
}
if (count > 0) {
value = count;
Rast_set_d_value(rp, value, CELL_TYPE);
}
rp = G_incr_void_ptr(rp, Rast_cell_size(CELL_TYPE));
count_sum += count;
}
Rast_put_row(out_fd, result, CELL_TYPE);
}
G_percent(1, 1, 1);
Vect_close(&In);
Rast_close(out_fd);
if (count_sum < 1)
G_warning(_("No points found"));
exit(EXIT_SUCCESS);
}
int
Vect_break_lines_list(struct Map_info *Map, struct ilist *List_break,
struct ilist *List_ref, int type, struct Map_info *Err)
{
struct line_pnts *APoints, *BPoints, *Points;
struct line_pnts **AXLines, **BXLines;
struct line_cats *ACats, *BCats, *Cats;
int j, k, l, ret, atype, btype, aline, bline, found, iline, nlines;
int naxlines, nbxlines, nx;
double *xx = NULL, *yx = NULL, *zx = NULL;
struct bound_box ABox, BBox;
struct boxlist *List;
int nbreaks;
int touch1_n = 0, touch1_s = 0, touch1_e = 0, touch1_w = 0; /* other vertices except node1 touching box */
int touch2_n = 0, touch2_s = 0, touch2_e = 0, touch2_w = 0; /* other vertices except node2 touching box */
int is3d;
int node, anode1, anode2, bnode1, bnode2;
double nodex, nodey;
APoints = Vect_new_line_struct();
BPoints = Vect_new_line_struct();
Points = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(1);
is3d = Vect_is_3d(Map);
if (List_break) {
nlines = List_break->n_values;
}
else {
nlines = Vect_get_num_lines(Map);
}
G_debug(3, "nlines = %d", nlines);
/* TODO: It seems that lines/boundaries are not broken at intersections
* with points/centroids. Check if true, if yes, skip GV_POINTS
*/
/* To find intersection of two lines (Vect_line_intersection) is quite slow.
* Fortunately usual lines/boundaries in GIS often forms a network where lines
* are connected by end points, and touch by MBR. This function checks and occasionaly
* skips such cases. This is currently done for 2D only
*/
/* Go through all lines in vector, for each select lines which overlap MBR of
* this line exclude those connected by one endpoint (see above)
* and try to intersect, if lines intersect write new lines at the end of
* the file, and process next line (remaining lines overlapping box are skipped)
*/
nbreaks = 0;
for (iline = 0; iline < nlines; iline++) {
G_percent(iline, nlines, 1);
if (List_break) {
aline = List_break->value[iline];
}
else {
aline = iline + 1;
}
if (List_ref && !Vect_val_in_list(List_ref, aline))
continue;
G_debug(3, "aline = %d", aline);
if (!Vect_line_alive(Map, aline))
continue;
atype = Vect_read_line(Map, APoints, ACats, aline);
if (!(atype & type))
continue;
Vect_line_box(APoints, &ABox);
/* Find which sides of the box are touched by intermediate (non-end) points of line */
if (!is3d) {
touch1_n = touch1_s = touch1_e = touch1_w = 0;
for (j = 1; j < APoints->n_points; j++) {
if (APoints->y[j] == ABox.N)
touch1_n = 1;
if (APoints->y[j] == ABox.S)
touch1_s = 1;
if (APoints->x[j] == ABox.E)
touch1_e = 1;
if (APoints->x[j] == ABox.W)
touch1_w = 1;
}
G_debug(3, "touch1: n = %d s = %d e = %d w = %d", touch1_n,
touch1_s, touch1_e, touch1_w);
touch2_n = touch2_s = touch2_e = touch2_w = 0;
for (j = 0; j < APoints->n_points - 1; j++) {
if (APoints->y[j] == ABox.N)
touch2_n = 1;
if (APoints->y[j] == ABox.S)
touch2_s = 1;
if (APoints->x[j] == ABox.E)
touch2_e = 1;
if (APoints->x[j] == ABox.W)
touch2_w = 1;
}
G_debug(3, "touch2: n = %d s = %d e = %d w = %d", touch2_n,
touch2_s, touch2_e, touch2_w);
}
Vect_select_lines_by_box(Map, &ABox, type, List);
G_debug(3, " %d lines selected by box", List->n_values);
for (j = 0; j < List->n_values; j++) {
bline = List->id[j];
if (List_break && !Vect_val_in_list(List_break, bline)) {
continue;
}
G_debug(3, " j = %d bline = %d", j, bline);
btype = Vect_read_line(Map, BPoints, BCats, bline);
/* Check if thouch by end node only */
if (!is3d) {
Vect_get_line_nodes(Map, aline, &anode1, &anode2);
Vect_get_line_nodes(Map, bline, &bnode1, &bnode2);
BBox = List->box[j];
if (anode1 == bnode1 || anode1 == bnode2)
node = anode1;
else if (anode2 == bnode1 || anode2 == bnode2)
node = anode2;
else
node = 0;
if (node) {
Vect_get_node_coor(Map, node, &nodex, &nodey, NULL);
if ((node == anode1 && nodey == ABox.N &&
!touch1_n && nodey == BBox.S) ||
(node == anode2 && nodey == ABox.N &&
!touch2_n && nodey == BBox.S) ||
(node == anode1 && nodey == ABox.S &&
!touch1_s && nodey == BBox.N) ||
(node == anode2 && nodey == ABox.S &&
!touch2_s && nodey == BBox.N) ||
(node == anode1 && nodex == ABox.E &&
!touch1_e && nodex == BBox.W) ||
(node == anode2 && nodex == ABox.E &&
!touch2_e && nodex == BBox.W) ||
(node == anode1 && nodex == ABox.W &&
!touch1_w && nodex == BBox.E) ||
(node == anode2 && nodex == ABox.W &&
!touch2_w && nodex == BBox.E)) {
G_debug(3,
"lines %d and %d touching by end nodes only -> no intersection",
aline, bline);
continue;
}
}
}
AXLines = NULL;
BXLines = NULL;
Vect_line_intersection(APoints, BPoints, &AXLines, &BXLines,
&naxlines, &nbxlines, 0);
G_debug(3, " naxlines = %d nbxlines = %d", naxlines, nbxlines);
/* This part handles a special case when aline == bline, no other intersection was found
* and the line is forming collapsed loop, for example 0,0;1,0;0,0 should be broken at 1,0.
* ---> */
if (aline == bline && naxlines == 0 && nbxlines == 0 &&
APoints->n_points >= 3) {
int centre;
int i;
G_debug(3, " Check collapsed loop");
if (APoints->n_points % 2) { /* odd number of vertices */
centre = APoints->n_points / 2; /* index of centre */
if (APoints->x[centre - 1] == APoints->x[centre + 1] && APoints->y[centre - 1] == APoints->y[centre + 1] && APoints->z[centre - 1] == APoints->z[centre + 1]) { /* -> break */
AXLines =
(struct line_pnts **)G_malloc(2 *
sizeof(struct
line_pnts
*));
AXLines[0] = Vect_new_line_struct();
AXLines[1] = Vect_new_line_struct();
for (i = 0; i <= centre; i++)
Vect_append_point(AXLines[0], APoints->x[i],
APoints->y[i], APoints->z[i]);
for (i = centre; i < APoints->n_points; i++)
Vect_append_point(AXLines[1], APoints->x[i],
APoints->y[i], APoints->z[i]);
naxlines = 2;
}
}
}
/* <--- */
if (Err) { /* array for intersections (more than needed */
xx = (double *)G_malloc((naxlines + nbxlines) *
sizeof(double));
yx = (double *)G_malloc((naxlines + nbxlines) *
sizeof(double));
zx = (double *)G_malloc((naxlines + nbxlines) *
sizeof(double));
}
nx = 0; /* number of intersections to be written to Err */
if (naxlines > 0) { /* intersection -> write out */
Vect_delete_line(Map, aline);
for (k = 0; k < naxlines; k++) {
/* Write new line segments */
/* line may collapse, don't write zero length lines */
Vect_line_prune(AXLines[k]);
if ((atype & GV_POINTS) || AXLines[k]->n_points > 1) {
ret = Vect_write_line(Map, atype, AXLines[k], ACats);
if (List_ref) {
Vect_list_append(List_ref, ret);
}
G_debug(3, "Line %d written, npoints = %d", ret,
AXLines[k]->n_points);
if (List_break) {
Vect_list_append(List_break, ret);
}
}
/* Write intersection points */
if (Err) {
if (k > 0) {
xx[nx] = AXLines[k]->x[0];
yx[nx] = AXLines[k]->y[0];
zx[nx] = AXLines[k]->z[0];
nx++;
}
}
Vect_destroy_line_struct(AXLines[k]);
}
nbreaks += naxlines - 1;
}
if (AXLines)
G_free(AXLines);
if (nbxlines > 0) {
if (aline != bline) { /* Self intersection, do not write twice, TODO: is it OK? */
Vect_delete_line(Map, bline);
for (k = 0; k < nbxlines; k++) {
/* Write new line segments */
/* line may collapse, don't write zero length lines */
Vect_line_prune(BXLines[k]);
if ((btype & GV_POINTS) || BXLines[k]->n_points > 1) {
ret =
Vect_write_line(Map, btype, BXLines[k],
BCats);
G_debug(5, "Line %d written", ret);
if (List_break) {
Vect_list_append(List_break, ret);
}
}
/* Write intersection points */
if (Err) {
if (k > 0) {
found = 0;
for (l = 0; l < nx; l++) {
if (xx[l] == BXLines[k]->x[0] &&
yx[l] == BXLines[k]->y[0] &&
zx[l] == BXLines[k]->z[0]) {
found = 1;
break;
}
}
if (!found) {
xx[nx] = BXLines[k]->x[0];
yx[nx] = BXLines[k]->y[0];
zx[nx] = BXLines[k]->z[0];
nx++;
}
}
}
Vect_destroy_line_struct(BXLines[k]);
}
nbreaks += nbxlines - 1;
}
else {
for (k = 0; k < nbxlines; k++)
Vect_destroy_line_struct(BXLines[k]);
}
}
if (BXLines)
G_free(BXLines);
if (Err) {
for (l = 0; l < nx; l++) { /* Write out errors */
Vect_reset_line(Points);
Vect_append_point(Points, xx[l], yx[l], zx[l]);
ret = Vect_write_line(Err, GV_POINT, Points, Cats);
}
G_free(xx);
G_free(yx);
G_free(zx);
}
if (naxlines > 0)
break; /* first line was broken and deleted -> take the next one */
}
if (List_break) {
nlines = List_break->n_values;
}
else {
nlines = Vect_get_num_lines(Map);
}
G_debug(3, "nlines = %d", nlines);
} /* for each line */
G_percent(nlines, nlines, 1); /* finish it */
G_verbose_message(_("Intersections: %d"), nbreaks);
Vect_destroy_line_struct(APoints);
Vect_destroy_line_struct(BPoints);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(ACats);
Vect_destroy_cats_struct(BCats);
Vect_destroy_cats_struct(Cats);
Vect_destroy_boxlist(List);
return nbreaks;
}
int nodes(struct Map_info *In, struct Map_info *Out, int add_cats, int nfield)
{
int i, node, nnodes, line, nlines, count, type, add_point;
double x, y, z;
struct line_pnts *Points, *Pout;
struct line_cats *Cats;
struct boxlist *List;
struct bound_box box;
int cat;
Points = Vect_new_line_struct();
Pout = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/* Rewrite all primitives to output file */
cat = 0;
while ((type = Vect_read_next_line(In, Points, Cats)) >= 0) {
if (type == GV_POINT) {
/* Get max cat in input */
int j;
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == nfield && Cats->cat[j] > cat) {
cat = Cats->cat[j];
}
}
}
Vect_write_line(Out, type, Points, Cats);
}
cat++;
/* Go through all nodes in old map and write a new point if missing */
nnodes = Vect_get_num_nodes(In);
count = 0;
for (node = 1; node <= nnodes; node++) {
nlines = Vect_get_node_n_lines(In, node);
add_point = 0;
for (i = 0; i < nlines; i++) {
line = abs(Vect_get_node_line(In, node, i));
type = Vect_read_line(In, NULL, NULL, line);
if (type & GV_LINES) {
add_point = 1;
break;
}
}
if (add_point) {
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);
add_point = List->n_values == 0;
}
if (add_point) { /* Write new point */
Vect_reset_line(Pout);
Vect_append_point(Pout, x, y, z);
Vect_reset_cats(Cats);
if (add_cats) {
Vect_cat_set(Cats, nfield, cat++);
}
Vect_write_line(Out, GV_POINT, Pout, Cats);
count++;
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Pout);
Vect_destroy_cats_struct(Cats);
Vect_destroy_boxlist(List);
return count;
}
int main(int argc, char *argv[])
{
int i, j, k;
int print_as_matrix; /* only for all */
int all; /* calculate from each to each within the threshold */
struct GModule *module;
struct Option *from_opt, *to_opt, *from_type_opt, *to_type_opt,
*from_field_opt, *to_field_opt;
struct Option *out_opt, *max_opt, *min_opt, *table_opt;
struct Option *upload_opt, *column_opt, *to_column_opt;
struct Flag *print_flag, *all_flag;
struct Map_info From, To, Out, *Outp;
int from_type, to_type, from_field, to_field;
double max, min;
double *max_step;
int n_max_steps, curr_step;
struct line_pnts *FPoints, *TPoints;
struct line_cats *FCats, *TCats;
NEAR *Near, *near;
int anear; /* allocated space, used only for all */
UPLOAD *Upload; /* zero terminated */
int ftype, fcat, tcat, count;
int nfrom, nto, nfcats, fline, tline, tseg, tarea, area, isle, nisles;
double tx, ty, tz, dist, talong, tmp_tx, tmp_ty, tmp_tz, tmp_dist,
tmp_talong;
struct field_info *Fi, *toFi;
dbString stmt, dbstr;
dbDriver *driver, *to_driver;
int *catexist, ncatexist, *cex;
char buf1[2000], buf2[2000];
int update_ok, update_err, update_exist, update_notexist, update_dupl,
update_notfound;
struct boxlist *List;
struct bound_box box;
dbCatValArray cvarr;
dbColumn *column;
all = 0;
print_as_matrix = 0;
column = NULL;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
module->description =
_("Finds the nearest element in vector map 'to' for elements in vector map 'from'.");
from_opt = G_define_standard_option(G_OPT_V_INPUT);
from_opt->key = "from";
from_opt->description = _("Name of existing vector map (from)");
from_opt->guisection = _("From");
from_field_opt = G_define_standard_option(G_OPT_V_FIELD);
from_field_opt->key = "from_layer";
from_field_opt->label = _("Layer number or name (from)");
from_field_opt->guisection = _("From");
from_type_opt = G_define_standard_option(G_OPT_V_TYPE);
from_type_opt->key = "from_type";
from_type_opt->options = "point,centroid";
from_type_opt->answer = "point";
from_type_opt->label = _("Feature type (from)");
from_type_opt->guisection = _("From");
to_opt = G_define_standard_option(G_OPT_V_INPUT);
to_opt->key = "to";
to_opt->description = _("Name of existing vector map (to)");
to_opt->guisection = _("To");
to_field_opt = G_define_standard_option(G_OPT_V_FIELD);
to_field_opt->key = "to_layer";
to_field_opt->label = _("Layer number or name (to)");
to_field_opt->guisection = _("To");
to_type_opt = G_define_standard_option(G_OPT_V_TYPE);
to_type_opt->key = "to_type";
to_type_opt->options = "point,line,boundary,centroid,area";
to_type_opt->answer = "point,line,area";
to_type_opt->label = _("Feature type (to)");
to_type_opt->guisection = _("To");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->key = "output";
out_opt->required = NO;
out_opt->description = _("Name for output vector map containing lines "
"connecting nearest elements");
max_opt = G_define_option();
max_opt->key = "dmax";
max_opt->type = TYPE_DOUBLE;
max_opt->required = NO;
max_opt->answer = "-1";
max_opt->description = _("Maximum distance or -1 for no limit");
min_opt = G_define_option();
min_opt->key = "dmin";
min_opt->type = TYPE_DOUBLE;
min_opt->required = NO;
min_opt->answer = "-1";
min_opt->description = _("Minimum distance or -1 for no limit");
upload_opt = G_define_option();
upload_opt->key = "upload";
upload_opt->type = TYPE_STRING;
upload_opt->required = YES;
upload_opt->multiple = YES;
upload_opt->options = "cat,dist,to_x,to_y,to_along,to_angle,to_attr";
upload_opt->description =
_("Values describing the relation between two nearest features");
upload_opt->descriptions =
_("cat;category of the nearest feature;"
"dist;minimum distance to nearest feature;"
"to_x;x coordinate of the nearest point on 'to' feature;"
"to_y;y coordinate of the nearest point on 'to' feature;"
"to_along;distance between points/centroids in 'from' map and the linear feature's "
"start point in 'to' map, along this linear feature;"
"to_angle;angle between the linear feature in 'to' map and the positive x axis, at "
"the location of point/centroid in 'from' map, counterclockwise, in radians, which "
"is between -PI and PI inclusive;"
"to_attr;attribute of nearest feature given by to_column option");
/* "from_x - x coordinate of the nearest point on 'from' feature;" */
/* "from_y - y coordinate of the nearest point on 'from' feature;" */
/* "from_along - distance to the nearest point on 'from' feature along linear feature;" */
column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
column_opt->required = YES;
column_opt->multiple = YES;
column_opt->description =
_("Column name(s) where values specified by 'upload' option will be uploaded");
column_opt->guisection = _("From_map");
to_column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
to_column_opt->key = "to_column";
to_column_opt->description =
_("Column name of nearest feature (used with upload=to_attr)");
to_column_opt->guisection = _("To");
table_opt = G_define_standard_option(G_OPT_DB_TABLE);
table_opt->gisprompt = "new_dbtable,dbtable,dbtable";
table_opt->description =
_("Name of table created for output when the distance to all flag is used");
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->label =
_("Print output to stdout, don't update attribute table");
print_flag->description =
_("First column is always category of 'from' feature called from_cat");
all_flag = G_define_flag();
all_flag->key = 'a';
all_flag->label =
_("Calculate distances to all features within the threshold");
all_flag->description = _("The output is written to stdout but may be uploaded "
"to a new table created by this module. "
"From categories are may be multiple."); /* huh? */
/* GUI dependency */
from_opt->guidependency = G_store(from_field_opt->key);
sprintf(buf1, "%s,%s", to_field_opt->key, to_column_opt->key);
to_opt->guidependency = G_store(buf1);
to_field_opt->guidependency = G_store(to_column_opt->key);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
from_type = Vect_option_to_types(from_type_opt);
to_type = Vect_option_to_types(to_type_opt);
from_field = atoi(from_field_opt->answer);
max = atof(max_opt->answer);
min = atof(min_opt->answer);
if (all_flag->answer)
all = 1;
/* Read upload and column options */
/* count */
i = 0;
while (upload_opt->answers[i])
i++;
if (strcmp(from_opt->answer, to_opt->answer) == 0 &&
all && !table_opt->answer && i == 1)
print_as_matrix = 1;
/* alloc */
Upload = (UPLOAD *) G_calloc(i + 1, sizeof(UPLOAD));
/* read upload */
i = 0;
while (upload_opt->answers[i]) {
if (strcmp(upload_opt->answers[i], "cat") == 0)
Upload[i].upload = CAT;
else if (strcmp(upload_opt->answers[i], "from_x") == 0)
Upload[i].upload = FROM_X;
else if (strcmp(upload_opt->answers[i], "from_y") == 0)
Upload[i].upload = FROM_Y;
else if (strcmp(upload_opt->answers[i], "to_x") == 0)
Upload[i].upload = TO_X;
else if (strcmp(upload_opt->answers[i], "to_y") == 0)
Upload[i].upload = TO_Y;
else if (strcmp(upload_opt->answers[i], "from_along") == 0)
Upload[i].upload = FROM_ALONG;
else if (strcmp(upload_opt->answers[i], "to_along") == 0)
Upload[i].upload = TO_ALONG;
else if (strcmp(upload_opt->answers[i], "dist") == 0)
Upload[i].upload = DIST;
else if (strcmp(upload_opt->answers[i], "to_angle") == 0)
Upload[i].upload = TO_ANGLE;
else if (strcmp(upload_opt->answers[i], "to_attr") == 0) {
if (!(to_column_opt->answer)) {
G_fatal_error(_("to_column option missing"));
}
Upload[i].upload = TO_ATTR;
}
i++;
}
Upload[i].upload = END;
/* read columns */
i = 0;
while (column_opt->answers[i]) {
if (Upload[i].upload == END) {
G_warning(_("Too many column names"));
break;
}
Upload[i].column = G_store(column_opt->answers[i]);
i++;
}
if (Upload[i].upload != END)
G_fatal_error(_("Not enough column names"));
/* Open 'from' vector */
Vect_set_open_level(2);
Vect_open_old(&From, from_opt->answer, G_mapset());
/* Open 'to' vector */
Vect_set_open_level(2);
Vect_open_old2(&To, to_opt->answer, "", to_field_opt->answer);
to_field = Vect_get_field_number(&To, to_field_opt->answer);
/* Open output vector */
if (out_opt->answer) {
Vect_open_new(&Out, out_opt->answer, WITHOUT_Z);
Vect_hist_command(&Out);
Outp = &Out;
}
else {
Outp = NULL;
}
/* TODO: add maxdist = -1 to Vect_select_ !!! */
/* Calc maxdist */
n_max_steps = 1;
if (max != 0) {
struct bound_box fbox, tbox;
double dx, dy, dz, tmp_max;
int n_features = 0;
Vect_get_map_box(&From, &fbox);
Vect_get_map_box(&To, &tbox);
Vect_box_extend(&fbox, &tbox);
dx = fbox.E - fbox.W;
dy = fbox.N - fbox.S;
if (Vect_is_3d(&From))
dz = fbox.T - fbox.B;
else
dz = 0.0;
tmp_max = sqrt(dx * dx + dy * dy + dz * dz);
if (max < 0)
max = tmp_max;
/* how to determine a reasonable number of steps to increase the search box? */
/* with max > 0 but max <<< tmp_max, 2 steps are sufficient, first 0 then max
* a reasonable number of steps also depends on the number of features in To
* e.g. only one area in To, no need to step */
nto = Vect_get_num_lines(&To);
for (tline = 1; tline <= nto; tline++) {
/* TODO: Vect_get_line_type() */
n_features += ((to_type & To.plus.Line[tline]->type) != 0);
}
if (to_type & GV_AREA) {
if (Vect_get_num_areas(&To) > n_features)
n_features = Vect_get_num_areas(&To);
}
if (n_features == 0)
G_fatal_error(_("No features of selected type in To vector <%s>"),
to_opt->answer);
n_max_steps = sqrt(n_features) * max / tmp_max;
/* max 9 steps from testing */
if (n_max_steps > 9)
n_max_steps = 9;
if (n_max_steps < 2)
n_max_steps = 2;
if (n_max_steps > n_features)
n_max_steps = n_features;
G_debug(2, "max = %f", max);
G_debug(2, "maximum reasonable search distance = %f", tmp_max);
G_debug(2, "n_features = %d", n_features);
G_debug(2, "n_max_steps = %d", n_max_steps);
}
if (min > max)
G_fatal_error("dmin can not be larger than dmax");
if (n_max_steps > 1) {
/* set up steps to increase search box */
max_step = G_malloc(n_max_steps * sizeof(double));
/* first step always 0 */
max_step[0] = 0;
for (curr_step = 1; curr_step < n_max_steps - 1; curr_step++) {
/* for 9 steps, this would be max / [128, 64, 32, 16, 8, 4, 2] */
max_step[curr_step] = max / (2 << (n_max_steps - 1 - curr_step));
}
/* last step always max */
max_step[n_max_steps - 1] = max;
}
else {
max_step = G_malloc(sizeof(double));
max_step[0] = max;
}
/* Open database driver */
db_init_string(&stmt);
db_init_string(&dbstr);
driver = NULL;
if (!print_flag->answer) {
if (!all) {
Fi = Vect_get_field(&From, from_field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
from_field);
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
/* check if column exists */
i = 0;
while (column_opt->answers[i]) {
db_get_column(driver, Fi->table, column_opt->answers[i],
&column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
column_opt->answers[i], Fi->table);
}
i++;
}
}
else {
driver = db_start_driver_open_database(NULL, NULL);
if (driver == NULL)
G_fatal_error(_("Unable to open default database"));
}
}
to_driver = NULL;
if (to_column_opt->answer) {
toFi = Vect_get_field(&To, to_field);
if (toFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
to_field);
to_driver =
db_start_driver_open_database(toFi->driver, toFi->database);
if (to_driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
toFi->database, toFi->driver);
/* check if to_column exists */
db_get_column(to_driver, toFi->table, to_column_opt->answer, &column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
to_column_opt->answer, toFi->table);
}
/* Check column types */
if (!print_flag->answer && !all) {
char *fcname = NULL;
int fctype, tctype;
i = 0;
while (column_opt->answers[i]) {
if (Upload[i].upload == TO_ATTR) {
fcname = column_opt->answers[i];
break;
}
i++;
}
if (fcname) {
fctype = db_column_Ctype(driver, Fi->table, fcname);
tctype =
db_column_Ctype(to_driver, toFi->table,
to_column_opt->answer);
if (((tctype == DB_C_TYPE_STRING ||
tctype == DB_C_TYPE_DATETIME)
&& (fctype == DB_C_TYPE_INT ||
fctype == DB_C_TYPE_DOUBLE)) ||
((tctype == DB_C_TYPE_INT || tctype == DB_C_TYPE_DOUBLE)
&& (fctype == DB_C_TYPE_STRING ||
fctype == DB_C_TYPE_DATETIME))
) {
G_fatal_error(_("Incompatible column types"));
}
}
}
}
FPoints = Vect_new_line_struct();
TPoints = Vect_new_line_struct();
FCats = Vect_new_cats_struct();
TCats = Vect_new_cats_struct();
List = Vect_new_boxlist(1);
/* Allocate space ( may be more than needed (duplicate cats and elements without cats) ) */
nfrom = Vect_get_num_lines(&From);
nto = Vect_get_num_lines(&To);
if (all) {
/* Attention with space for all, it can easily run out of memory */
anear = 2 * nfrom;
Near = (NEAR *) G_calloc(anear, sizeof(NEAR));
}
else {
Near = (NEAR *) G_calloc(nfrom, sizeof(NEAR));
}
/* Read all cats from 'from' */
if (!all) {
nfcats = 0;
for (i = 1; i <= nfrom; i++) {
ftype = Vect_read_line(&From, NULL, FCats, i);
/* This keeps also categories of areas for future (if area s in from_type) */
if (!(ftype & from_type) &&
(ftype != GV_CENTROID || !(from_type & GV_AREA)))
continue;
Vect_cat_get(FCats, from_field, &fcat);
if (fcat < 0)
continue;
Near[nfcats].from_cat = fcat;
nfcats++;
}
G_debug(1, "%d cats loaded from vector (including duplicates)",
nfcats);
/* Sort by cats and remove duplicates */
qsort((void *)Near, nfcats, sizeof(NEAR), cmp_near);
/* remove duplicates */
for (i = 1; i < nfcats; i++) {
if (Near[i].from_cat == Near[i - 1].from_cat) {
for (j = i; j < nfcats - 1; j++) {
Near[j].from_cat = Near[j + 1].from_cat;
}
nfcats--;
}
}
G_debug(1, "%d cats loaded from vector (unique)", nfcats);
}
/* Go through all lines in 'from' and find nearest in 'to' for each */
/* Note: as from_type is restricted to GV_POINTS (for now) everything is simple */
count = 0; /* count of distances in 'all' mode */
/* Find nearest lines */
if (to_type & (GV_POINTS | GV_LINES)) {
struct line_pnts *LLPoints;
if (G_projection() == PROJECTION_LL) {
LLPoints = Vect_new_line_struct();
}
else {
LLPoints = NULL;
}
G_message(_("Finding nearest feature..."));
for (fline = 1; fline <= nfrom; fline++) {
int tmp_tcat;
double tmp_tangle, tangle;
double tmp_min = (min < 0 ? 0 : min);
double box_edge = 0;
int done = 0;
curr_step = 0;
G_debug(3, "fline = %d", fline);
G_percent(fline, nfrom, 2);
ftype = Vect_read_line(&From, FPoints, FCats, fline);
if (!(ftype & from_type))
continue;
Vect_cat_get(FCats, from_field, &fcat);
if (fcat < 0 && !all)
continue;
while (!done) {
done = 1;
if (!all) {
/* enlarge search box until we get a hit */
/* the objective is to enlarge the search box
* in the first iterations just a little bit
* to keep the number of hits low */
Vect_reset_boxlist(List);
while (curr_step < n_max_steps) {
box_edge = max_step[curr_step];
if (box_edge < tmp_min)
continue;
box.E = FPoints->x[0] + box_edge;
box.W = FPoints->x[0] - box_edge;
box.N = FPoints->y[0] + box_edge;
box.S = FPoints->y[0] - box_edge;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&To, &box, to_type, List);
curr_step++;
if (List->n_values > 0)
break;
}
}
else {
box.E = FPoints->x[0] + max;
box.W = FPoints->x[0] - max;
box.N = FPoints->y[0] + max;
box.S = FPoints->y[0] - max;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&To, &box, to_type, List);
}
G_debug(3, " %d lines in box", List->n_values);
tline = 0;
dist = PORT_DOUBLE_MAX;
for (i = 0; i < List->n_values; i++) {
tmp_tcat = -1;
Vect_read_line(&To, TPoints, TCats, List->id[i]);
tseg =
Vect_line_distance(TPoints, FPoints->x[0], FPoints->y[0],
FPoints->z[0], (Vect_is_3d(&From) &&
Vect_is_3d(&To)) ?
WITH_Z : WITHOUT_Z, &tmp_tx, &tmp_ty,
&tmp_tz, &tmp_dist, NULL, &tmp_talong);
Vect_point_on_line(TPoints, tmp_talong, NULL, NULL, NULL,
&tmp_tangle, NULL);
if (tmp_dist > max || tmp_dist < min)
continue; /* not in threshold */
/* TODO: more cats of the same field */
Vect_cat_get(TCats, to_field, &tmp_tcat);
if (G_projection() == PROJECTION_LL) {
/* calculate distances in meters not degrees (only 2D) */
Vect_reset_line(LLPoints);
Vect_append_point(LLPoints, FPoints->x[0], FPoints->y[0],
FPoints->z[0]);
Vect_append_point(LLPoints, tmp_tx, tmp_ty, tmp_tz);
tmp_dist = Vect_line_geodesic_length(LLPoints);
Vect_reset_line(LLPoints);
for (k = 0; k < tseg; k++)
Vect_append_point(LLPoints, TPoints->x[k],
TPoints->y[k], TPoints->z[k]);
Vect_append_point(LLPoints, tmp_tx, tmp_ty, tmp_tz);
tmp_talong = Vect_line_geodesic_length(LLPoints);
}
G_debug(4, " tmp_dist = %f tmp_tcat = %d", tmp_dist,
tmp_tcat);
if (all) {
if (anear <= count) {
anear += 10 + nfrom / 10;
Near = (NEAR *) G_realloc(Near, anear * sizeof(NEAR));
}
near = &(Near[count]);
/* store info about relation */
near->from_cat = fcat;
near->to_cat = tmp_tcat; /* -1 is OK */
near->dist = tmp_dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->from_z = FPoints->z[0];
near->to_x = tmp_tx;
near->to_y = tmp_ty;
near->to_z = tmp_tz;
near->to_along = tmp_talong; /* 0 for points */
near->to_angle = tmp_tangle;
near->count++;
count++;
}
else {
if (tline == 0 || (tmp_dist < dist)) {
tline = List->id[i];
tcat = tmp_tcat;
dist = tmp_dist;
tx = tmp_tx;
ty = tmp_ty;
tz = tmp_tz;
talong = tmp_talong;
tangle = tmp_tangle;
}
}
}
G_debug(4, " dist = %f", dist);
if (curr_step < n_max_steps) {
/* enlarging the search box is possible */
if (tline > 0 && dist > box_edge) {
/* line found but distance > search edge:
* line bbox overlaps with search box, line itself is outside search box */
done = 0;
}
else if (tline == 0) {
/* no line within max dist, but search box can still be enlarged */
done = 0;
}
}
if (done && !all && tline > 0) {
/* find near by cat */
near =
(NEAR *) bsearch((void *)&fcat, Near, nfcats,
sizeof(NEAR), cmp_near);
G_debug(4, " near.from_cat = %d near.count = %d",
near->from_cat, near->count);
/* store info about relation */
if (near->count == 0 || near->dist > dist) {
near->to_cat = tcat; /* -1 is OK */
near->dist = dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->from_z = FPoints->z[0];
near->to_x = tx;
near->to_y = ty;
near->to_z = tz;
near->to_along = talong; /* 0 for points */
near->to_angle = tangle;
}
near->count++;
}
} /* done */
} /* next feature */
if (LLPoints) {
Vect_destroy_line_struct(LLPoints);
}
}
/* Find nearest areas */
if (to_type & GV_AREA) {
G_message(_("Finding nearest areas..."));
for (fline = 1; fline <= nfrom; fline++) {
double tmp_min = (min < 0 ? 0 : min);
double box_edge = 0;
int done = 0;
curr_step = 0;
G_debug(3, "fline = %d", fline);
G_percent(fline, nfrom, 2);
ftype = Vect_read_line(&From, FPoints, FCats, fline);
if (!(ftype & from_type))
continue;
Vect_cat_get(FCats, from_field, &fcat);
if (fcat < 0 && !all)
continue;
while (!done) {
done = 1;
if (!all) {
/* enlarge search box until we get a hit */
/* the objective is to enlarge the search box
* in the first iterations just a little bit
* to keep the number of hits low */
Vect_reset_boxlist(List);
while (curr_step < n_max_steps) {
box_edge = max_step[curr_step];
if (box_edge < tmp_min)
continue;
box.E = FPoints->x[0] + box_edge;
box.W = FPoints->x[0] - box_edge;
box.N = FPoints->y[0] + box_edge;
box.S = FPoints->y[0] - box_edge;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&To, &box, List);
curr_step++;
if (List->n_values > 0)
break;
}
}
else {
box.E = FPoints->x[0] + max;
box.W = FPoints->x[0] - max;
box.N = FPoints->y[0] + max;
box.S = FPoints->y[0] - max;
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_areas_by_box(&To, &box, List);
}
G_debug(4, "%d areas selected by box", List->n_values);
/* For each area in box check the distance */
tarea = 0;
dist = PORT_DOUBLE_MAX;
for (i = 0; i < List->n_values; i++) {
int tmp_tcat;
area = List->id[i];
G_debug(4, "%d: area %d", i, area);
Vect_get_area_points(&To, area, TPoints);
/* Find the distance to this area */
if (Vect_point_in_area(FPoints->x[0], FPoints->y[0], &To, area, List->box[i])) { /* in area */
tmp_dist = 0;
tmp_tx = FPoints->x[0];
tmp_ty = FPoints->y[0];
}
else if (Vect_point_in_poly(FPoints->x[0], FPoints->y[0], TPoints) > 0) { /* in isle */
nisles = Vect_get_area_num_isles(&To, area);
for (j = 0; j < nisles; j++) {
double tmp2_dist, tmp2_tx, tmp2_ty;
isle = Vect_get_area_isle(&To, area, j);
Vect_get_isle_points(&To, isle, TPoints);
Vect_line_distance(TPoints, FPoints->x[0],
FPoints->y[0], FPoints->z[0],
WITHOUT_Z, &tmp2_tx, &tmp2_ty,
NULL, &tmp2_dist, NULL, NULL);
if (j == 0 || tmp2_dist < tmp_dist) {
tmp_dist = tmp2_dist;
tmp_tx = tmp2_tx;
tmp_ty = tmp2_ty;
}
}
}
else { /* outside area */
Vect_line_distance(TPoints, FPoints->x[0], FPoints->y[0],
FPoints->z[0], WITHOUT_Z, &tmp_tx,
&tmp_ty, NULL, &tmp_dist, NULL, NULL);
}
if (tmp_dist > max || tmp_dist < min)
continue; /* not in threshold */
Vect_get_area_cats(&To, area, TCats);
tmp_tcat = -1;
/* TODO: all cats of given field ? */
for (j = 0; j < TCats->n_cats; j++) {
if (TCats->field[j] == to_field) {
if (tmp_tcat >= 0)
G_warning(_("More cats found in to_layer (area=%d)"),
area);
tmp_tcat = TCats->cat[j];
}
}
G_debug(4, " tmp_dist = %f tmp_tcat = %d", tmp_dist,
tmp_tcat);
if (all) {
if (anear <= count) {
anear += 10 + nfrom / 10;
Near = (NEAR *) G_realloc(Near, anear * sizeof(NEAR));
}
near = &(Near[count]);
/* store info about relation */
near->from_cat = fcat;
near->to_cat = tmp_tcat; /* -1 is OK */
near->dist = tmp_dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->to_x = tmp_tx;
near->to_y = tmp_ty;
near->to_along = 0; /* nonsense for areas */
near->to_angle = 0; /* not supported for areas */
near->count++;
count++;
}
else if (tarea == 0 || tmp_dist < dist) {
tarea = area;
tcat = tmp_tcat;
dist = tmp_dist;
tx = tmp_tx;
ty = tmp_ty;
}
}
if (curr_step < n_max_steps) {
/* enlarging the search box is possible */
if (tarea > 0 && dist > box_edge) {
/* area found but distance > search edge:
* area bbox overlaps with search box, area itself is outside search box */
done = 0;
}
else if (tarea == 0) {
/* no area within max dist, but search box can still be enlarged */
done = 0;
}
}
if (done && !all && tarea > 0) {
/* find near by cat */
near =
(NEAR *) bsearch((void *)&fcat, Near, nfcats,
sizeof(NEAR), cmp_near);
G_debug(4, "near.from_cat = %d near.count = %d dist = %f",
near->from_cat, near->count, near->dist);
/* store info about relation */
if (near->count == 0 || near->dist > dist) {
near->to_cat = tcat; /* -1 is OK */
near->dist = dist;
near->from_x = FPoints->x[0];
near->from_y = FPoints->y[0];
near->to_x = tx;
near->to_y = ty;
near->to_along = 0; /* nonsense for areas */
near->to_angle = 0; /* not supported for areas */
}
near->count++;
}
} /* done */
} /* next feature */
}
G_debug(3, "count = %d", count);
/* Update database / print to stdout / create output map */
if (print_flag->answer) { /* print header */
fprintf(stdout, "from_cat");
i = 0;
while (Upload[i].upload != END) {
fprintf(stdout, "|%s", Upload[i].column);
i++;
}
fprintf(stdout, "\n");
}
else if (all && table_opt->answer) { /* create new table */
db_set_string(&stmt, "create table ");
db_append_string(&stmt, table_opt->answer);
db_append_string(&stmt, " (from_cat integer");
j = 0;
while (Upload[j].upload != END) {
db_append_string(&stmt, ", ");
switch (Upload[j].upload) {
case CAT:
sprintf(buf2, "%s integer", Upload[j].column);
break;
case DIST:
case FROM_X:
case FROM_Y:
case TO_X:
case TO_Y:
case FROM_ALONG:
case TO_ALONG:
case TO_ANGLE:
sprintf(buf2, "%s double precision", Upload[j].column);
}
db_append_string(&stmt, buf2);
j++;
}
db_append_string(&stmt, " )");
G_debug(3, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) != DB_OK)
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
if (db_grant_on_table(driver, table_opt->answer, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
table_opt->answer);
}
else if (!all) { /* read existing cats from table */
ncatexist =
db_select_int(driver, Fi->table, Fi->key, NULL, &catexist);
G_debug(1, "%d cats selected from the table", ncatexist);
}
update_ok = update_err = update_exist = update_notexist = update_dupl =
update_notfound = 0;
if (!all) {
count = nfcats;
}
else if (print_as_matrix) {
qsort((void *)Near, count, sizeof(NEAR), cmp_near_to);
}
if (driver)
db_begin_transaction(driver);
/* select 'to' attributes */
if (to_column_opt->answer) {
int nrec;
db_CatValArray_init(&cvarr);
nrec = db_select_CatValArray(to_driver, toFi->table, toFi->key,
to_column_opt->answer, NULL, &cvarr);
G_debug(3, "selected values = %d", nrec);
if (cvarr.ctype == DB_C_TYPE_DATETIME) {
G_warning(_("DATETIME type not yet supported, no attributes will be uploaded"));
}
db_close_database_shutdown_driver(to_driver);
}
if (!(print_flag->answer || (all && !table_opt->answer))) /* no printing */
G_message("Update database...");
for (i = 0; i < count; i++) {
dbCatVal *catval = 0;
if (!(print_flag->answer || (all && !table_opt->answer))) /* no printing */
G_percent(i, count, 1);
/* Write line connecting nearest points */
if (Outp != NULL) {
Vect_reset_line(FPoints);
Vect_reset_cats(FCats);
Vect_append_point(FPoints, Near[i].from_x, Near[i].from_y, 0);
if (Near[i].dist == 0) {
Vect_write_line(Outp, GV_POINT, FPoints, FCats);
}
else {
Vect_append_point(FPoints, Near[i].to_x, Near[i].to_y, 0);
Vect_write_line(Outp, GV_LINE, FPoints, FCats);
}
}
if (Near[i].count > 1)
update_dupl++;
if (Near[i].count == 0)
update_notfound++;
if (to_column_opt->answer && Near[i].count > 0) {
db_CatValArray_get_value(&cvarr, Near[i].to_cat, &catval);
}
if (print_flag->answer || (all && !table_opt->answer)) { /* print only */
/*
input and output is the same &&
calculate distances &&
only one upload option given ->
print as a matrix
*/
if (print_as_matrix) {
if (i == 0) {
for (j = 0; j < nfrom; j++) {
if (j == 0)
fprintf(stdout, " ");
fprintf(stdout, "|%d", Near[j].to_cat);
}
fprintf(stdout, "\n");
}
if (i % nfrom == 0) {
fprintf(stdout, "%d", Near[i].from_cat);
for (j = 0; j < nfrom; j++) {
print_upload(Near, Upload, i + j, &cvarr, catval);
}
fprintf(stdout, "\n");
}
}
else {
fprintf(stdout, "%d", Near[i].from_cat);
print_upload(Near, Upload, i, &cvarr, catval);
fprintf(stdout, "\n");
}
}
else if (all) { /* insert new record */
sprintf(buf1, "insert into %s values ( %d ", table_opt->answer,
Near[i].from_cat);
db_set_string(&stmt, buf1);
j = 0;
while (Upload[j].upload != END) {
db_append_string(&stmt, ",");
switch (Upload[j].upload) {
case CAT:
sprintf(buf2, " %d", Near[i].to_cat);
break;
case DIST:
sprintf(buf2, " %f", Near[i].dist);
break;
case FROM_X:
sprintf(buf2, " %f", Near[i].from_x);
break;
case FROM_Y:
sprintf(buf2, " %f", Near[i].from_y);
break;
case TO_X:
sprintf(buf2, " %f", Near[i].to_x);
break;
case TO_Y:
sprintf(buf2, " %f", Near[i].to_y);
break;
case FROM_ALONG:
sprintf(buf2, " %f", Near[i].from_along);
break;
case TO_ALONG:
sprintf(buf2, " %f", Near[i].to_along);
break;
case TO_ANGLE:
sprintf(buf2, " %f", Near[i].to_angle);
break;
case TO_ATTR:
if (catval) {
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
sprintf(buf2, " %d", catval->val.i);
break;
case DB_C_TYPE_DOUBLE:
sprintf(buf2, " %.15e", catval->val.d);
break;
case DB_C_TYPE_STRING:
db_set_string(&dbstr,
db_get_string(catval->val.s));
db_double_quote_string(&dbstr);
sprintf(buf2, " '%s'", db_get_string(&dbstr));
break;
case DB_C_TYPE_DATETIME:
/* TODO: formating datetime */
sprintf(buf2, " null");
break;
}
}
else {
sprintf(buf2, " null");
}
break;
}
db_append_string(&stmt, buf2);
j++;
}
db_append_string(&stmt, " )");
G_debug(3, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
else { /* update table */
/* check if exists in table */
cex =
(int *)bsearch((void *)&(Near[i].from_cat), catexist,
ncatexist, sizeof(int), cmp_exist);
if (cex == NULL) { /* cat does not exist in DB */
update_notexist++;
continue;
}
update_exist++;
sprintf(buf1, "update %s set", Fi->table);
db_set_string(&stmt, buf1);
j = 0;
while (Upload[j].upload != END) {
if (j > 0)
db_append_string(&stmt, ",");
sprintf(buf2, " %s =", Upload[j].column);
db_append_string(&stmt, buf2);
if (Near[i].count == 0) { /* no nearest found */
db_append_string(&stmt, " null");
}
else {
switch (Upload[j].upload) {
case CAT:
if (Near[i].to_cat > 0)
sprintf(buf2, " %d", Near[i].to_cat);
else
sprintf(buf2, " null");
break;
case DIST:
sprintf(buf2, " %f", Near[i].dist);
break;
case FROM_X:
sprintf(buf2, " %f", Near[i].from_x);
break;
case FROM_Y:
sprintf(buf2, " %f", Near[i].from_y);
break;
case TO_X:
sprintf(buf2, " %f", Near[i].to_x);
break;
case TO_Y:
sprintf(buf2, " %f", Near[i].to_y);
break;
case FROM_ALONG:
sprintf(buf2, " %f", Near[i].from_along);
break;
case TO_ALONG:
sprintf(buf2, " %f", Near[i].to_along);
break;
case TO_ANGLE:
sprintf(buf2, " %f", Near[i].to_angle);
break;
case TO_ATTR:
if (catval) {
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
sprintf(buf2, " %d", catval->val.i);
break;
case DB_C_TYPE_DOUBLE:
sprintf(buf2, " %.15e", catval->val.d);
break;
case DB_C_TYPE_STRING:
db_set_string(&dbstr,
db_get_string(catval->val.s));
db_double_quote_string(&dbstr);
sprintf(buf2, " '%s'", db_get_string(&dbstr));
break;
case DB_C_TYPE_DATETIME:
/* TODO: formating datetime */
sprintf(buf2, " null");
break;
}
}
else {
sprintf(buf2, " null");
}
break;
}
db_append_string(&stmt, buf2);
}
j++;
}
sprintf(buf2, " where %s = %d", Fi->key, Near[i].from_cat);
db_append_string(&stmt, buf2);
G_debug(2, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(driver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
}
G_percent(count, count, 1);
if (driver)
db_commit_transaction(driver);
/* print stats */
if (update_dupl > 0)
G_message(_("%d categories with more than 1 feature in vector map <%s>"),
update_dupl, from_opt->answer);
if (update_notfound > 0)
G_message(_("%d categories - no nearest feature found"),
update_notfound);
if (!print_flag->answer) {
db_close_database_shutdown_driver(driver);
db_free_string(&stmt);
/* print stats */
if (all && table_opt->answer) {
G_message(_("%d distances calculated"), count);
G_message(_("%d records inserted"), update_ok);
if (update_err > 0)
G_message(_("%d insert errors"), update_err);
}
else if (!all) {
if (nfcats > 0)
G_message(_("%d categories read from the map"), nfcats);
if (ncatexist > 0)
G_message(_("%d categories exist in the table"), ncatexist);
if (update_exist > 0)
G_message(_("%d categories read from the map exist in the table"),
update_exist);
if (update_notexist > 0)
G_message(_("%d categories read from the map don't exist in the table"),
update_notexist);
G_message(_("%d records updated"), update_ok);
if (update_err > 0)
G_message(_("%d update errors"), update_err);
G_free(catexist);
}
Vect_set_db_updated(&From);
}
Vect_close(&From);
if (Outp != NULL) {
Vect_build(Outp);
Vect_close(Outp);
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
}