int main(int argc, char *argv[])
{
int i, iopt;
int operator;
int aline, nalines, nskipped;
int ltype, itype[2], ifield[2];
int **cats, *ncats, nfields, *fields;
char *mapset[2], *pre[2];
struct GModule *module;
struct GParm parm;
struct GFlag flag;
struct Map_info In[2], Out;
struct field_info *IFi, *OFi;
struct line_pnts *APoints, *BPoints;
struct line_cats *ACats, *BCats;
int *ALines; /* List of lines: 0 do not output, 1 - write to output */
struct ilist *List, *TmpList, *BoundList;
G_gisinit(argv[0]);
pre[0] = "a";
pre[1] = "b";
module = G_define_module();
module->keywords = _("vector, spatial query");
module->description =
_("Selects features from vector map (A) by features from other vector map (B).");
parse_options(&parm, &flag);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (parm.operator->answer[0] == 'e')
operator = OP_EQUALS;
else if (parm.operator->answer[0] == 'd') {
/* operator = OP_DISJOINT; */
operator = OP_INTERSECTS;
flag.reverse->answer = YES;
}
else if (parm.operator->answer[0] == 'i')
operator = OP_INTERSECTS;
else if (parm.operator->answer[0] == 't')
operator = OP_TOUCHES;
else if (parm.operator->answer[0] == 'c' && parm.operator->answer[1] == 'r')
operator = OP_CROSSES;
else if (parm.operator->answer[0] == 'w')
operator = OP_WITHIN;
else if (parm.operator->answer[0] == 'c' && parm.operator->answer[1] == 'o')
operator = OP_CONTAINS;
else if (parm.operator->answer[0] == 'o') {
if (strcmp(parm.operator->answer, "overlaps") == 0)
operator = OP_OVERLAPS;
else
operator = OP_OVERLAP;
}
else if (parm.operator->answer[0] == 'r')
operator = OP_RELATE;
else
G_fatal_error(_("Unknown operator"));
if (operator == OP_RELATE && !parm.relate->answer) {
G_fatal_error(_("Required parameter <%s> not set"),
parm.relate->key);
}
for (iopt = 0; iopt < 2; iopt++) {
itype[iopt] = Vect_option_to_types(parm.type[iopt]);
ifield[iopt] = atoi(parm.field[iopt]->answer);
Vect_check_input_output_name(parm.input[iopt]->answer, parm.output->answer,
GV_FATAL_EXIT);
if ((mapset[iopt] =
G_find_vector2(parm.input[iopt]->answer, NULL)) == NULL) {
G_fatal_error(_("Vector map <%s> not found"),
parm.input[iopt]->answer);
}
Vect_set_open_level(2);
Vect_open_old(&(In[iopt]), parm.input[iopt]->answer, mapset[iopt]);
}
/* Read field info */
IFi = Vect_get_field(&(In[0]), ifield[0]);
APoints = Vect_new_line_struct();
BPoints = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
List = Vect_new_list();
TmpList = Vect_new_list();
BoundList = Vect_new_list();
/* Open output */
Vect_open_new(&Out, parm.output->answer, Vect_is_3d(&(In[0])));
Vect_set_map_name(&Out, _("Output from v.select"));
Vect_set_person(&Out, G_whoami());
Vect_copy_head_data(&(In[0]), &Out);
Vect_hist_copy(&(In[0]), &Out);
Vect_hist_command(&Out);
nskipped = 0;
nalines = Vect_get_num_lines(&(In[0]));
#ifdef HAVE_GEOS
initGEOS(G_message, G_fatal_error);
GEOSGeometry *AGeom = NULL;
#else
void *AGeom = NULL;
#endif
/* Alloc space for input lines array */
ALines = (int *)G_calloc(nalines + 1, sizeof(int));
G_message(_("Building spatial index..."));
Vect_build_spatial_index(&In[0]);
Vect_build_spatial_index(&In[1]);
/* Lines in A. Go through all lines and mark those that meets condition */
if (itype[0] & (GV_POINTS | GV_LINES)) {
G_message(_("Processing features..."));
for (aline = 1; aline <= nalines; aline++) {
BOUND_BOX abox;
G_debug(3, "aline = %d", aline);
G_percent(aline, nalines, 2); /* must be before any continue */
/* Check category */
if (!flag.cat->answer && Vect_get_line_cat(&(In[0]), aline, ifield[0]) < 0) {
nskipped++;
continue;
}
/* Read line and check type */
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
AGeom = Vect_read_line_geos(&(In[0]), aline, <ype);
#endif
if (!(ltype & (GV_POINT | GV_LINE)))
continue;
if (!AGeom)
G_fatal_error(_("Unable to read line id %d from vector map <%s>"),
aline, Vect_get_full_name(&(In[0])));
}
else {
ltype = Vect_read_line(&(In[0]), APoints, NULL, aline);
}
if (!(ltype & itype[0]))
continue;
Vect_get_line_box(&(In[0]), aline, &abox);
abox.T = PORT_DOUBLE_MAX;
abox.B = -PORT_DOUBLE_MAX;
/* Check if this line overlaps any feature in B */
/* x Lines in B */
if (itype[1] & (GV_POINTS | GV_LINES)) {
int i;
int found = 0;
/* Lines */
Vect_select_lines_by_box(&(In[1]), &abox, itype[1], List);
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->value[i];
G_debug(3, " bline = %d", bline);
/* Check category */
if (!flag.cat->answer && Vect_get_line_cat(&(In[1]), bline, ifield[1]) < 0) {
nskipped++;
continue;
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(line_relate_geos(&(In[1]), AGeom,
bline, operator, parm.relate->answer)) {
found = 1;
break;
}
#endif
}
else {
Vect_read_line(&(In[1]), BPoints, NULL, bline);
if (Vect_line_check_intersection(APoints, BPoints, 0)) {
found = 1;
break;
}
}
}
if (found) {
ALines[aline] = 1;
continue; /* Go to next A line */
}
}
/* x Areas in B. */
if (itype[1] & GV_AREA) {
int i;
Vect_select_areas_by_box(&(In[1]), &abox, List);
for (i = 0; i < List->n_values; i++) {
int barea;
barea = List->value[i];
G_debug(3, " barea = %d", barea);
if (Vect_get_area_cat(&(In[1]), barea, ifield[1]) < 0) {
nskipped++;
continue;
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(area_relate_geos(&(In[1]), AGeom,
barea, operator, parm.relate->answer)) {
ALines[aline] = 1;
break;
}
#endif
}
else {
if (line_overlap_area(&(In[0]), aline, &(In[1]), barea)) {
ALines[aline] = 1;
break;
}
}
}
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
GEOSGeom_destroy(AGeom);
#endif
AGeom = NULL;
}
}
}
/* Areas in A. */
if (itype[0] & GV_AREA) {
int aarea, naareas;
G_message(_("Processing areas..."));
naareas = Vect_get_num_areas(&(In[0]));
for (aarea = 1; aarea <= naareas; aarea++) {
BOUND_BOX abox;
G_percent(aarea, naareas, 2); /* must be before any continue */
if (Vect_get_area_cat(&(In[0]), aarea, ifield[0]) < 0) {
nskipped++;
continue;
}
Vect_get_area_box(&(In[0]), aarea, &abox);
abox.T = PORT_DOUBLE_MAX;
abox.B = -PORT_DOUBLE_MAX;
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
AGeom = Vect_read_area_geos(&(In[0]), aarea);
#endif
if (!AGeom)
G_fatal_error(_("Unable to read area id %d from vector map <%s>"),
aline, Vect_get_full_name(&(In[0])));
}
/* x Lines in B */
if (itype[1] & (GV_POINTS | GV_LINES)) {
Vect_select_lines_by_box(&(In[1]), &abox, itype[1], List);
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->value[i];
if (!flag.cat->answer && Vect_get_line_cat(&(In[1]), bline, ifield[1]) < 0) {
nskipped++;
continue;
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(line_relate_geos(&(In[1]), AGeom,
bline, operator, parm.relate->answer)) {
add_aarea(&(In[0]), aarea, ALines);
break;
}
#endif
}
else {
if (line_overlap_area(&(In[1]), bline, &(In[0]), aarea)) {
add_aarea(&(In[0]), aarea, ALines);
continue;
}
}
}
}
/* x Areas in B */
if (itype[1] & GV_AREA) {
int naisles;
int found = 0;
/* List of areas B */
/* Make a list of features forming area A */
Vect_reset_list(List);
Vect_get_area_boundaries(&(In[0]), aarea, BoundList);
for (i = 0; i < BoundList->n_values; i++) {
Vect_list_append(List, abs(BoundList->value[i]));
}
naisles = Vect_get_area_num_isles(&(In[0]), aarea);
for (i = 0; i < naisles; i++) {
int j, aisle;
aisle = Vect_get_area_isle(&(In[0]), aarea, i);
Vect_get_isle_boundaries(&(In[0]), aisle, BoundList);
for (j = 0; j < BoundList->n_values; j++) {
Vect_list_append(List, BoundList->value[j]);
}
}
Vect_select_areas_by_box(&(In[1]), &abox, TmpList);
for (i = 0; i < List->n_values; i++) {
int j, aline;
aline = abs(List->value[i]);
for (j = 0; j < TmpList->n_values; j++) {
int barea, bcentroid;
barea = TmpList->value[j];
G_debug(3, " barea = %d", barea);
if (Vect_get_area_cat(&(In[1]), barea, ifield[1]) < 0) {
nskipped++;
continue;
}
/* Check if any centroid of area B is in area A.
* This test is important in if area B is completely within area A */
bcentroid = Vect_get_area_centroid(&(In[1]), barea);
Vect_read_line(&(In[1]), BPoints, NULL, bcentroid);
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(area_relate_geos(&(In[1]), AGeom,
barea, operator, parm.relate->answer)) {
found = 1;
break;
}
#endif
}
else {
if (Vect_point_in_area(&(In[0]), aarea,
BPoints->x[0], BPoints->y[0])) {
found = 1;
break;
}
/* Check intersectin of lines from List with area B */
if (line_overlap_area(&(In[0]), aline,
&(In[1]), barea)) {
found = 1;
break;
}
}
}
if (found) {
add_aarea(&(In[0]), aarea, ALines);
break;
}
}
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
GEOSGeom_destroy(AGeom);
#endif
AGeom = NULL;
}
}
}
Vect_close(&(In[1]));
#ifdef HAVE_GEOS
finishGEOS();
#endif
/* Write lines */
nfields = Vect_cidx_get_num_fields(&(In[0]));
cats = (int **)G_malloc(nfields * sizeof(int *));
ncats = (int *)G_malloc(nfields * sizeof(int));
fields = (int *)G_malloc(nfields * sizeof(int));
for (i = 0; i < nfields; i++) {
ncats[i] = 0;
cats[i] =
(int *)G_malloc(Vect_cidx_get_num_cats_by_index(&(In[0]), i) *
sizeof(int));
fields[i] = Vect_cidx_get_field_number(&(In[0]), i);
}
G_message(_("Writing selected features..."));
for (aline = 1; aline <= nalines; aline++) {
int atype;
G_debug(4, "aline = %d ALines[aline] = %d", aline, ALines[aline]);
G_percent(aline, nalines, 2);
if ((!flag.reverse->answer && !(ALines[aline])) ||
(flag.reverse->answer && ALines[aline]))
continue;
atype = Vect_read_line(&(In[0]), APoints, ACats, aline);
Vect_write_line(&Out, atype, APoints, ACats);
if (!(flag.table->answer) && (IFi != NULL)) {
for (i = 0; i < ACats->n_cats; i++) {
int f, j;
for (j = 0; j < nfields; j++) { /* find field */
if (fields[j] == ACats->field[i]) {
f = j;
break;
}
}
cats[f][ncats[f]] = ACats->cat[i];
ncats[f]++;
}
}
}
/* Copy tables */
if (!(flag.table->answer)) {
int ttype, ntabs = 0;
G_message(_("Writing attributes..."));
/* Number of output tabs */
for (i = 0; i < Vect_get_num_dblinks(&(In[0])); i++) {
int f, j;
IFi = Vect_get_dblink(&(In[0]), i);
for (j = 0; j < nfields; j++) { /* find field */
if (fields[j] == IFi->number) {
f = j;
break;
}
}
if (ncats[f] > 0)
ntabs++;
}
if (ntabs > 1)
ttype = GV_MTABLE;
else
ttype = GV_1TABLE;
for (i = 0; i < nfields; i++) {
int ret;
if (fields[i] == 0)
continue;
/* Make a list of categories */
IFi = Vect_get_field(&(In[0]), fields[i]);
if (!IFi) { /* no table */
G_warning(_("Layer %d - no table"), fields[i]);
continue;
}
OFi =
Vect_default_field_info(&Out, IFi->number, IFi->name, ttype);
ret =
db_copy_table_by_ints(IFi->driver, IFi->database, IFi->table,
OFi->driver,
Vect_subst_var(OFi->database, &Out),
OFi->table, IFi->key, cats[i],
ncats[i]);
if (ret == DB_FAILED) {
G_warning(_("Layer %d - unable to copy table"), fields[i]);
}
else {
Vect_map_add_dblink(&Out, OFi->number, OFi->name, OFi->table,
IFi->key, OFi->database, OFi->driver);
}
}
}
Vect_close(&(In[0]));
Vect_build(&Out);
Vect_close(&Out);
if (nskipped > 0) {
G_warning(_("%d features without category skipped"), nskipped);
}
G_done_msg(_("%d features written to output."), Vect_get_num_lines(&Out));
exit(EXIT_SUCCESS);
}
/*!
\brief Set values in 'varray' to 'value'.
if category of object of given type is in categories selected from
DB based on where statement (given without where). 'type' may be
either: GV_AREA or: GV_POINT | GV_LINE | GV_BOUNDARY | GV_CENTROID
Array is not reset to zero before, but old values (if any > 0) are
overwritten. Array must be initialised by Vect_new_varray(size) call.
\param Map vector map
\param field layer number
\param where where statement
\param type feature type
\param value value to set up
\param[in,out] varray varray structure to modify
\return number of items set
\return -1 on error
*/
int
Vect_set_varray_from_db(struct Map_info *Map, int field, const char *where,
int type, int value, VARRAY * varray)
{
int i, n, c, centr, cat, *cats;
int ncats;
int ni = 0; /* number of items set */
int ltype; /* line type */
struct line_cats *Cats;
struct field_info *Fi;
dbDriver *driver;
G_debug(4, "Vect_set_varray_from_db(): field = %d where = '%s'", field,
where);
/* Note: use category index once available */
/* Check type */
if ((type & GV_AREA) && (type & (GV_POINTS | GV_LINES))) {
G_warning(_("Mixed area and other type requested for vector array"));
return 0;
}
Cats = Vect_new_cats_struct();
/* Select categories from DB to array */
Fi = Vect_get_field(Map, field);
if (Fi == NULL) {
G_warning(_("Database connection not defined for layer %d"), field);
return -1;
}
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
return -1;
}
ncats = db_select_int(driver, Fi->table, Fi->key, where, &cats);
db_close_database_shutdown_driver(driver);
if (ncats == -1) {
G_warning(_("Unable to select record from table <%s> (key %s, where %s)"),
Fi->table, Fi->key, where);
return -1;
}
if (type & GV_AREA) { /* Areas */
n = Vect_get_num_areas(Map);
/* IMHO varray should be allocated only when it's required AND only as large as required
as WHERE will create a small subset of all vector features and thus on large datasets
it's waste of memory to allocate it for all features. */
if (n > varray->size) { /* not enough space */
G_warning(_("Not enough space in vector array"));
return 0;
}
for (i = 1; i <= n; i++) {
centr = Vect_get_area_centroid(Map, i);
if (centr <= 0)
continue; /* No centroid */
Vect_read_line(Map, NULL, Cats, centr);
/*if ( !Vect_cat_get(Cats, field, &cat) ) continue; No such field */
for (c = 0; c < Cats->n_cats; c++) {
if (Cats->field[c] == field &&
in_array(cats, ncats, Cats->cat[c])) {
cat = Cats->cat[c];
varray->c[i] = value;
ni++;
break;
}
}
/*
if ( in_array ( cats, ncats, cat ) ) {
varray->c[i] = value;
ni++;
}
*/
}
}
else { /* Lines */
n = Vect_get_num_lines(Map);
if (n > varray->size) { /* not enough space */
G_warning(_("Not enough space in vector array"));
return 0;
}
for (i = 1; i <= n; i++) {
ltype = Vect_read_line(Map, NULL, Cats, i);
if (!(ltype & type))
continue; /* is not specified type */
/* if ( !Vect_cat_get(Cats, field, &cat) ) continue; No such field */
for (c = 0; c < Cats->n_cats; c++) {
if (Cats->field[c] == field &&
in_array(cats, ncats, Cats->cat[c])) {
cat = Cats->cat[c];
varray->c[i] = value;
ni++;
break;
}
}
/*
if ( in_array ( cats, ncats, cat ) ) {
varray->c[i] = value;
ni++;
}
*/
}
}
G_free(cats);
Vect_destroy_cats_struct(Cats);
return ni;
}
void select_from_database(void)
{
int nrec, ctype, nlines, line, nareas, area;
struct line_pnts *Points;
Fi = Vect_get_field(&Map, ofield);
if (Fi == NULL) {
G_fatal_error(_(" Database connection not defined for layer <%s>"), field_opt->answer);
}
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error("Unable to open database <%s> by driver <%s>",
Fi->database, Fi->driver);
db_set_error_handler_driver(Driver);
/* check if column exists */
ctype = db_column_Ctype(Driver, Fi->table, col_opt->answer);
if (ctype == -1)
G_fatal_error(_("Column <%s> not found in table <%s>"),
col_opt->answer, Fi->table);
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Only numeric column type is supported"));
/* Note do not check if the column exists in the table because it may be an expression */
db_CatValArray_init(&Cvarr);
nrec = db_select_CatValArray(Driver, Fi->table, Fi->key, col_opt->answer,
where_opt->answer, &Cvarr);
G_debug(2, "db_select_CatValArray() nrec = %d", nrec);
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
db_close_database_shutdown_driver(Driver);
Points = Vect_new_line_struct();
/* Lines */
nlines = 0;
if ((otype & GV_POINTS) || (otype & GV_LINES))
nlines = Vect_get_num_lines(&Map);
G_debug(1, "select_from_database: %d points", nlines);
for (line = 1; line <= nlines; line++) {
int i, type;
G_debug(3, "line = %d", line);
G_percent(line, nlines, 2);
type = Vect_read_line(&Map, Points, Cats, line);
if (!(type & otype))
continue;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == ofield) {
double val = 0.0;
dbCatVal *catval;
G_debug(3, "cat = %d", Cats->cat[i]);
if (db_CatValArray_get_value(&Cvarr, Cats->cat[i], &catval) !=
DB_OK) {
G_debug(3, "No record for cat = %d", Cats->cat[i]);
nmissing++;
continue;
}
if (catval->isNull) {
G_debug(3, "NULL value for cat = %d", Cats->cat[i]);
nnull++;
continue;
}
if (ctype == DB_C_TYPE_INT) {
val = catval->val.i;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
val = catval->val.d;
}
count++;
if (first) {
max = val;
min = val;
first = 0;
}
else {
if (val > max)
max = val;
if (val < min)
min = val;
}
if (compatible) {
if (type & GV_POINTS) {
sum += val;
sumsq += val * val;
sumcb += val * val * val;
sumqt += val * val * val * val;
sum_abs += fabs(val);
}
else if (type & GV_LINES) { /* GV_LINES */
double l = 1.;
if (weight_flag->answer)
l = Vect_line_length(Points);
sum += l * val;
sumsq += l * val * val;
sumcb += l * val * val * val;
sumqt += l * val * val * val * val;
sum_abs += l * fabs(val);
total_size += l;
}
}
G_debug(3, "sum = %f total_size = %f", sum, total_size);
}
}
}
if (otype & GV_AREA) {
nareas = Vect_get_num_areas(&Map);
for (area = 1; area <= nareas; area++) {
int i, centr;
G_debug(3, "area = %d", area);
centr = Vect_get_area_centroid(&Map, area);
if (centr < 1)
continue;
G_debug(3, "centr = %d", centr);
Vect_read_line(&Map, NULL, Cats, centr);
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == ofield) {
double val = 0.0;
dbCatVal *catval;
G_debug(3, "cat = %d", Cats->cat[i]);
if (db_CatValArray_get_value
(&Cvarr, Cats->cat[i], &catval) != DB_OK) {
G_debug(3, "No record for cat = %d", Cats->cat[i]);
nmissing++;
continue;
}
if (catval->isNull) {
G_debug(3, "NULL value for cat = %d", Cats->cat[i]);
nnull++;
continue;
}
if (ctype == DB_C_TYPE_INT) {
val = catval->val.i;
}
else if (ctype == DB_C_TYPE_DOUBLE) {
val = catval->val.d;
}
count++;
if (first) {
max = val;
min = val;
first = 0;
}
else {
if (val > max)
max = val;
if (val < min)
min = val;
}
if (compatible) {
double a = 1.;
if (weight_flag->answer)
a = Vect_get_area_area(&Map, area);
sum += a * val;
sumsq += a * val * val;
sumcb += a * val * val * val;
sumqt += a * val * val * val * val;
sum_abs += a * fabs(val);
total_size += a;
}
G_debug(4, "sum = %f total_size = %f", sum, total_size);
}
}
}
}
G_debug(2, "sum = %f total_size = %f", sum, total_size);
}
/*!
\brief Set values in 'varray' to 'value'
If category of object of given type is in 'clist' (category list).
'type' may be either: GV_AREA or: GV_POINT | GV_LINE | GV_BOUNDARY |
GV_CENTROID
Array is not reset to zero before, but old values (if any > 0) are overwritten.
Array must be initialised by Vect_new_varray(size) call.
\param Map vector map
\param field layer number
\param clist list of categories
\param type feature type
\param value value to set up
\param[in,out] varray varray structure to modify
\return number of items set
\return -1 on error
*/
int
Vect_set_varray_from_cat_list(struct Map_info *Map, int field,
struct cat_list *clist, int type, int value,
VARRAY * varray)
{
int i, n, centr, cat;
int ni = 0; /* number of items set */
int ltype; /* line type */
struct line_cats *Cats;
G_debug(4, "Vect_set_varray_from_cat_list(): field = %d", field);
/* Check type */
if ((type & GV_AREA) && (type & (GV_POINTS | GV_LINES))) {
G_warning(_("Mixed area and other type requested for vector array"));
return 0;
}
Cats = Vect_new_cats_struct();
if (type & GV_AREA) { /* Areas */
n = Vect_get_num_areas(Map);
if (n > varray->size) { /* not enough space */
G_warning(_("Not enough space in vector array"));
return 0;
}
for (i = 1; i <= n; i++) {
centr = Vect_get_area_centroid(Map, i);
if (centr <= 0)
continue; /* No centroid */
Vect_read_line(Map, NULL, Cats, centr);
if (!Vect_cat_get(Cats, field, &cat))
continue; /* No such field */
if (Vect_cat_in_cat_list(cat, clist)) { /* cat is in list */
varray->c[i] = value;
ni++;
}
}
}
else { /* Lines */
n = Vect_get_num_lines(Map);
if (n > varray->size) { /* not enough space */
G_warning(_("Not enough space in vector array"));
return 0;
}
for (i = 1; i <= n; i++) {
ltype = Vect_read_line(Map, NULL, Cats, i);
if (!(ltype & type))
continue; /* is not specified type */
if (!Vect_cat_get(Cats, field, &cat))
continue; /* No such field */
if (Vect_cat_in_cat_list(cat, clist)) { /* cat is in list */
varray->c[i] = value;
ni++;
}
}
}
Vect_destroy_cats_struct(Cats);
return ni;
}
int display_area(struct Map_info *Map, struct cat_list *Clist, const struct Cell_head *window,
const struct color_rgb *bcolor, const struct color_rgb *fcolor, int chcat,
int id_flag, int cats_color_flag,
int default_width, double width_scale,
struct Colors *zcolors,
dbCatValArray *cvarr_rgb, struct Colors *colors,
dbCatValArray *cvarr_width, int nrec_width)
{
int num, area, isle, n_isles, n_points;
double xl, yl;
struct line_pnts *Points, * APoints, **IPoints;
struct line_cats *Cats;
int n_ipoints_alloc;
int cat, centroid;
int red, grn, blu;
int i, custom_rgb, found;
int width;
struct bound_box box;
if (Vect_level(Map) < 2) {
G_warning(_("Unable to display areas, topology not available. "
"Please try to rebuild topology using "
"v.build or v.build.all."));
return 1;
}
G_debug(1, "display areas:");
centroid = 0;
Points = Vect_new_line_struct();
APoints = Vect_new_line_struct();
n_ipoints_alloc = 10;
IPoints = (struct line_pnts **)G_malloc(n_ipoints_alloc * sizeof(struct line_pnts *));
for (i = 0; i < n_ipoints_alloc; i++) {
IPoints[i] = Vect_new_line_struct();
}
Cats = Vect_new_cats_struct();
num = Vect_get_num_areas(Map);
G_debug(2, "\tn_areas = %d", num);
for (area = 1; area <= num; area++) {
G_debug(3, "\tarea = %d", area);
if (!Vect_area_alive(Map, area))
continue;
centroid = Vect_get_area_centroid(Map, area);
if (!centroid) {
continue;
}
/* Check box */
Vect_get_area_box(Map, area, &box);
if (box.N < window->south || box.S > window->north ||
box.E < window->west || box.W > window->east) {
if (window->proj != PROJECTION_LL)
continue;
else { /* out of bounds for -180 to 180, try 0 to 360 as well */
if (box.N < window->south || box.S > window->north)
continue;
if (box.E + 360 < window->west || box.W + 360 > window->east)
continue;
}
}
custom_rgb = FALSE;
found = FALSE;
if (chcat) {
if (id_flag) {
if (!(Vect_cat_in_cat_list(area, Clist)))
continue;
}
else {
G_debug(3, "centroid = %d", centroid);
if (centroid < 1)
continue;
Vect_read_line(Map, Points, Cats, centroid);
for (i = 0; i < Cats->n_cats; i++) {
G_debug(3, " centroid = %d, field = %d, cat = %d",
centroid, Cats->field[i], Cats->cat[i]);
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = TRUE;
break;
}
}
if (!found)
continue;
}
}
else if (Clist->field > 0) {
found = FALSE;
G_debug(3, "\tcentroid = %d", centroid);
if (centroid < 1)
continue;
Vect_read_line(Map, NULL, Cats, centroid);
for (i = 0; i < Cats->n_cats; i++) {
G_debug(3, "\tcentroid = %d, field = %d, cat = %d", centroid,
Cats->field[i], Cats->cat[i]);
if (Cats->field[i] == Clist->field) {
found = TRUE;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
/* fill */
Vect_get_area_points(Map, area, APoints);
G_debug(3, "\tn_points = %d", APoints->n_points);
if (APoints->n_points < 3) {
G_warning(_("Invalid area %d skipped (not enough points)"), area);
continue;
}
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
n_points = Points->n_points;
xl = Points->x[n_points - 1];
yl = Points->y[n_points - 1];
n_isles = Vect_get_area_num_isles(Map, area);
if (n_isles >= n_ipoints_alloc) {
IPoints = (struct line_pnts **)G_realloc(IPoints, (n_isles + 10) * sizeof(struct line_pnts *));
for (i = n_ipoints_alloc; i < n_isles + 10; i++) {
IPoints[i] = Vect_new_line_struct();
}
n_ipoints_alloc = n_isles + 10;
}
for (i = 0; i < n_isles; i++) {
isle = Vect_get_area_isle(Map, area, i);
Vect_get_isle_points(Map, isle, IPoints[i]);
Vect_append_points(Points, IPoints[i], GV_FORWARD);
Vect_append_point(Points, xl, yl, 0.0); /* ??? */
}
cat = Vect_get_area_cat(Map, area,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats > 0 ? Cats->field[0] : 1)));
if (!centroid && cat == -1) {
continue;
}
/* z height colors */
if (zcolors) {
if (Rast_get_d_color(&Points->z[0], &red, &grn, &blu, zcolors) == 1)
custom_rgb = TRUE;
else
custom_rgb = FALSE;
}
/* custom colors */
if (colors || cvarr_rgb) {
custom_rgb = get_table_color(cat, area, colors, cvarr_rgb,
&red, &grn, &blu);
}
/* random colors */
if (cats_color_flag) {
custom_rgb = get_cat_color(area, Cats, Clist,
&red, &grn, &blu);
}
/* line width */
if (nrec_width) {
width = (int) get_property(cat, area, cvarr_width,
(double) width_scale,
(double) default_width);
D_line_width(width);
}
if (fcolor || zcolors) {
if (!cvarr_rgb && !cats_color_flag && !zcolors && !colors) {
D_RGB_color(fcolor->r, fcolor->g, fcolor->b);
D_polygon_abs(Points->x, Points->y, Points->n_points);
}
else {
if (custom_rgb) {
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
}
else {
D_RGB_color(fcolor->r, fcolor->g, fcolor->b);
}
if (cat >= 0) {
D_polygon_abs(Points->x, Points->y, Points->n_points);
}
}
}
/* boundary */
if (bcolor) {
if (custom_rgb) {
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
}
else {
D_RGB_color(bcolor->r, bcolor->g, bcolor->b);
}
/* use different user defined render methods */
D_polyline_abs(APoints->x, APoints->y, APoints->n_points);
for (i = 0; i < n_isles; i++) {
/* use different user defined render methods */
D_polyline_abs(IPoints[i]->x, IPoints[i]->y, IPoints[i]->n_points);
}
}
}
if ((colors || cvarr_rgb) && get_num_color_rules_skipped() > 0)
G_warning(_n("%d invalid color rule for areas skipped",
"%d invalid color rules for areas skipped",
get_num_color_rules_skipped()),
get_num_color_rules_skipped());
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(APoints);
for (i = 0; i < n_ipoints_alloc; i++) {
Vect_destroy_line_struct(IPoints[i]);
}
G_free(IPoints);
Vect_destroy_cats_struct(Cats);
return 0;
}
int export_areas_single(struct Map_info *In, int field, int donocat,
OGRFeatureDefnH Ogr_featuredefn,OGRLayerH Ogr_layer,
struct field_info *Fi, dbDriver *driver, int ncol, int *colctype,
const char **colname, int doatt, int nocat,
int *n_noatt, int *n_nocat)
{
int i, j;
int centroid, cat, area, n_areas;
int n_exported;
struct line_pnts *Points;
struct line_cats *Cats;
OGRGeometryH Ogr_geometry;
OGRFeatureH Ogr_feature;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
n_exported = 0;
n_areas = Vect_get_num_areas(In);
for (i = 1; i <= n_areas; i++) {
G_percent(i, n_areas, 5);
/* get centroid's category */
centroid = Vect_get_area_centroid(In, i);
cat = -1;
if (centroid > 0) {
Vect_read_line(In, NULL, Cats, centroid);
Vect_cat_get(Cats, field, &cat);
}
G_debug(3, "area = %d centroid = %d ncats = %d", i, centroid,
Cats->n_cats);
if (cat < 0 && !donocat) {
(*n_nocat)++;
continue; /* skip areas without category, do not export
* not labeled */
}
/* find correspoding area */
area = Vect_get_centroid_area(In, centroid);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry = create_polygon(In, area, Points);
/* add feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
/* output one feature for each category */
for (j = -1; j < Cats->n_cats; j++) {
if (j == -1) {
if (cat >= 0)
continue; /* cat(s) exists */
(*n_nocat)++;
}
else {
if (Cats->field[j] == field)
cat = Cats->cat[j];
else
continue;
}
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
n_exported++;
}
OGR_G_DestroyGeometry(Ogr_geometry);
OGR_F_Destroy(Ogr_feature);
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return n_exported;
}
/*!
\brief Overlay 2 vector maps with AND.
AND supports:point line area
point + - +
line - - -
area + - -
\param AMap vector map A
\param atype feature type for A
\param AList unused ?
\param AAList unused ?
\param BMap vector map B
\param btype feature type for B
\param BList unused ?
\param BAList unused ?
\param operator operator code
\return 1 on success
\return 0 on error
*/
int
Vect_overlay_and(struct Map_info *AMap, int atype, struct ilist *AList,
struct ilist *AAList, struct Map_info *BMap, int btype,
struct ilist *BList, struct ilist *BAList,
struct Map_info *OMap)
{
int i, j, k, node, line, altype, bltype, oltype, area, centr;
struct line_pnts *Points;
struct line_cats *ACats, *BCats, *OCats;
struct ilist *AOList, *BOList;
/* TODO: support Lists */
Points = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
OCats = Vect_new_cats_struct();
AOList = Vect_new_list();
BOList = Vect_new_list();
/* TODO: support all types; at present only point x point, area x point and point x area supported */
if ((atype & GV_LINES) || (btype & GV_LINES))
G_warning(_("Overlay: line/boundary types not supported by AND operator"));
if ((atype & GV_AREA) && (btype & GV_AREA))
G_warning(_("Overlay: area x area types not supported by AND operator"));
/* TODO: more points in one node in one map */
/* point x point: select all points with identical coordinates in both maps */
if ((atype & GV_POINTS) && (btype & GV_POINTS)) { /* both points and centroids */
G_debug(3, "overlay: AND: point x point");
for (i = 1; i <= Vect_get_num_lines(AMap); i++) {
altype = Vect_read_line(AMap, Points, ACats, i);
if (!(altype & GV_POINTS))
continue;
node =
Vect_find_node(BMap, Points->x[0], Points->y[0], Points->z[0],
0, 1);
G_debug(3, "overlay: node = %d", node);
if (node == 0)
continue;
Vect_reset_cats(OCats);
for (j = 0; j < Vect_get_node_n_lines(BMap, node); j++) {
line = Vect_get_node_line(BMap, node, j);
bltype = Vect_read_line(BMap, NULL, BCats, line);
if (!(bltype & GV_POINTS))
continue;
/* Identical points found -> write out */
/* TODO: do something if fields in ACats and BCats are identical */
for (k = 0; k < ACats->n_cats; k++)
Vect_cat_set(OCats, ACats->field[k], ACats->cat[k]);
for (k = 0; k < BCats->n_cats; k++)
Vect_cat_set(OCats, BCats->field[k], BCats->cat[k]);
/* TODO: what to do if one type is GV_POINT and second GV_CENTROID */
oltype = altype;
Vect_write_line(OMap, oltype, Points, OCats);
Vect_list_append(AOList, i); /* add to list of written lines */
Vect_list_append(BOList, line);
break;
}
}
}
/* TODO: check only labeled areas */
/* point x area: select points from A in areas in B */
if ((atype & GV_POINTS) && (btype & GV_AREA)) { /* both points and centroids */
G_debug(3, "overlay: AND: point x area");
for (i = 1; i <= Vect_get_num_lines(AMap); i++) {
altype = Vect_read_line(AMap, Points, ACats, i);
if (!(altype & GV_POINTS))
continue;
area = Vect_find_area(BMap, Points->x[0], Points->y[0]);
if (area == 0)
continue;
Vect_reset_cats(OCats);
/* TODO: do something if fields in ACats and BCats are identical */
for (k = 0; k < ACats->n_cats; k++)
Vect_cat_set(OCats, ACats->field[k], ACats->cat[k]);
centr = Vect_get_area_centroid(BMap, area);
if (centr > 0) {
bltype = Vect_read_line(BMap, NULL, BCats, centr);
for (k = 0; k < BCats->n_cats; k++)
Vect_cat_set(OCats, BCats->field[k], BCats->cat[k]);
}
/* Check if not yet written */
if (!(Vect_val_in_list(AOList, i))) {
Vect_write_line(OMap, altype, Points, OCats);
Vect_list_append(AOList, i);
}
}
}
/* area x point: select points from B in areas in A */
if ((btype & GV_POINTS) && (atype & GV_AREA)) { /* both points and centroids */
G_debug(3, "overlay: AND: area x point");
for (i = 1; i <= Vect_get_num_lines(BMap); i++) {
bltype = Vect_read_line(BMap, Points, BCats, i);
if (!(bltype & GV_POINTS))
continue;
area = Vect_find_area(AMap, Points->x[0], Points->y[0]);
if (area == 0)
continue;
Vect_reset_cats(OCats);
/* TODO: do something if fields in ACats and BCats are identical */
for (k = 0; k < BCats->n_cats; k++)
Vect_cat_set(OCats, BCats->field[k], BCats->cat[k]);
centr = Vect_get_area_centroid(AMap, area);
if (centr > 0) {
altype = Vect_read_line(AMap, NULL, ACats, centr);
for (k = 0; k < ACats->n_cats; k++)
Vect_cat_set(OCats, ACats->field[k], ACats->cat[k]);
}
/* Check if not yet written */
if (!(Vect_val_in_list(BOList, i))) {
Vect_write_line(OMap, bltype, Points, OCats);
Vect_list_append(BOList, i);
}
}
}
return 0;
}
int main(int argc, char *argv[])
{
int i, j, precision, field;
int do_attr = 0, attr_cols[8], attr_size = 0, db_open = 0, cnt = 0;
double width, radius;
struct Option *in_opt, *out_opt, *prec_opt, *type_opt, *attr_opt,
*field_opt;
struct GModule *module;
struct Map_info In;
struct bound_box box;
/* vector */
struct line_pnts *Points;
struct line_cats *Cats;
/* attribs */
dbDriver *Driver = NULL;
dbHandle handle;
dbTable *Table;
dbString dbstring;
struct field_info *Fi;
/* init */
G_gisinit(argv[0]);
/* parse command-line */
module = G_define_module();
module->description = _("Exports a vector map to SVG file.");
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
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_F_OUTPUT);
out_opt->description = _("Name for SVG output file");
type_opt = G_define_option();
type_opt->key = "type";
type_opt->type = TYPE_STRING;
type_opt->required = YES;
type_opt->multiple = NO;
type_opt->answer = "poly";
type_opt->options = "poly,line,point";
type_opt->label = _("Output type");
type_opt->description = _("Defines which feature-type will be extracted");
prec_opt = G_define_option();
prec_opt->key = "precision";
prec_opt->type = TYPE_INTEGER;
prec_opt->required = NO;
prec_opt->answer = "6";
prec_opt->multiple = NO;
prec_opt->description = _("Coordinate precision");
attr_opt = G_define_standard_option(G_OPT_DB_COLUMNS);
attr_opt->key = "attribute";
attr_opt->required = NO;
attr_opt->multiple = YES;
attr_opt->description = _("Attribute(s) to include in output SVG");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* override coordinate precision if any */
precision = atof(prec_opt->answer);
if (precision < 0) {
G_fatal_error(_("Precision must not be negative"));
}
if (precision > 15) {
G_fatal_error(_("Precision must not be higher than 15"));
}
/* open input vector */
Vect_set_open_level(2);
Vect_open_old2(&In, in_opt->answer, "", field_opt->answer);
/* parse field number */
field = Vect_get_field_number(&In, field_opt->answer);
/* open db-driver to attribs */
db_init_string(&dbstring);
/* check for requested field */
Fi = Vect_get_field(&In, field);
if (Fi != NULL) {
Driver = db_start_driver(Fi->driver);
if (Driver == NULL) {
G_fatal_error(_("Unable to start driver <%s>"), Fi->driver);
}
/* open db */
db_init_handle(&handle);
db_set_handle(&handle, Fi->database, NULL);
if (db_open_database(Driver, &handle) != DB_OK) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
db_set_string(&dbstring, Fi->table);
if (db_describe_table(Driver, &dbstring, &Table) != DB_OK) {
G_fatal_error(_("Unable to describe table <%s>"), Fi->table);
}
/* define column-indices for columns to extract */
dbColumn *Column;
for (i = 0; i < db_get_table_number_of_columns(Table); i++) {
Column = db_get_table_column(Table, i);
if (attr_opt->answer != NULL) {
for (j = 0; attr_opt->answers[j] != NULL; j++) {
if (G_strcasecmp(attr_opt->answers[j],
db_get_column_name(Column)) == 0) {
attr_cols[attr_size] = i;
attr_size += 1;
break;
}
}
}
}
do_attr = 1;
db_open = 1;
}
/* parse bounding box and define default stroke-width, radius */
Vect_get_map_box(&In, &box);
if ((box.E - box.W) >= (box.N - box.S)) {
radius = (box.E - box.W) * RADIUS_SCALE;
width = (box.E - box.W) * WIDTH_SCALE;
}
else {
radius = (box.N - box.S) * RADIUS_SCALE;
width = (box.N - box.S) * WIDTH_SCALE;
}
/* open output SVG-file and print SVG-header with viewBox and Namenspaces */
if ((fpsvg = fopen(out_opt->answer, "w")) == NULL) {
G_fatal_error(_("Unable to create SVG file <%s>"), out_opt->answer);
}
fprintf(fpsvg, "<svg xmlns=\"%s\" xmlns:xlink=\"%s\" xmlns:gg=\"%s\" ",
SVG_NS, XLINK_NS, GRASS_NS);
fprintf(fpsvg, "viewBox=\"%.*f %.*f %.*f %.*f\">\n",
precision, box.W,
precision, box.N * -1,
precision, box.E - box.W, precision, box.N - box.S);
fprintf(fpsvg, "<title>v.out.svg %s %s</title>\n", in_opt->answer,
out_opt->answer);
/* extract areas if any or requested */
if (G_strcasecmp(type_opt->answer, "poly") == 0) {
if (Vect_get_num_areas(&In) == 0) {
G_warning(_("No areas found, skipping type=poly"));
}
else {
/* extract area as paths */
fprintf(fpsvg,
" <g id=\"%s\" fill=\"#CCC\" stroke=\"#000\" stroke-width=\"%.*f\" >\n",
G_Areas, precision, width);
for (i = 1; i <= Vect_get_num_areas(&In); i++) {
/* skip areas without centroid */
if (Vect_get_area_centroid(&In, i) == 0) {
G_warning(_("Skipping area %d without centroid"), i);
continue;
}
G_percent(i, Vect_get_num_areas(&In), 10);
/* extract attribs, parse area */
Vect_get_area_cats(&In, i, Cats);
fprintf(fpsvg, " <path ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[0], Fi, Driver, Table, attr_cols,
attr_size, do_attr);
}
fprintf(fpsvg, "d=\"");
Vect_get_area_points(&In, i, Points);
mk_path(Points, precision);
/* append islands if any within current path */
for (j = 0; j < Vect_get_area_num_isles(&In, i); j++) {
Vect_get_isle_points(&In, Vect_get_area_isle(&In, i, j),
Points);
mk_path(Points, precision);
}
fprintf(fpsvg, "\" />\n");
cnt += 1;
}
fprintf(fpsvg, " </g>\n");
G_message(_("Extracted %d areas"), cnt);
}
}
/* extract points if requested */
if (G_strcasecmp(type_opt->answer, "point") == 0) {
if (Vect_get_num_primitives(&In, GV_POINTS) == 0) {
G_warning(_("No points found, skipping type=point"));
}
else {
/* extract points as circles */
fprintf(fpsvg, " <g id=\"%s\" fill=\"#FC0\" stroke=\"#000\" "
"stroke-width=\"%.*f\" >\n", G_Points, precision, width);
for (i = 1; i <= Vect_get_num_primitives(&In, GV_POINTS); i++) {
G_percent(i, Vect_get_num_primitives(&In, GV_POINTS), 10);
Vect_read_line(&In, Points, Cats, i);
if (field != -1 && !Vect_cat_get(Cats, field, NULL))
continue;
for (j = 0; j < Points->n_points; j++) {
fprintf(fpsvg, " <circle ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[j], Fi, Driver, Table, attr_cols,
attr_size, do_attr);
}
fprintf(fpsvg, "cx=\"%.*f\" cy=\"%.*f\" r=\"%.*f\" />\n",
precision, Points->x[j],
precision, Points->y[j] * -1, precision, radius);
cnt += 1;
}
}
fprintf(fpsvg, " </g>\n");
G_message(_("Extracted %d points"), cnt);
}
}
/* extract lines if requested */
if (G_strcasecmp(type_opt->answer, "line") == 0) {
if (Vect_get_num_primitives(&In, GV_LINES) == 0) {
G_warning(_("No lines found, skipping type=line"));
}
else {
/* extract lines as paths */
fprintf(fpsvg, " <g id=\"%s\" fill=\"none\" stroke=\"#000\" "
"stroke-width=\"%.*f\" >\n", G_Lines, precision, width);
for (i = 1; i <= Vect_get_num_primitives(&In, GV_LINES); i++) {
G_percent(i, Vect_get_num_primitives(&In, GV_LINES), 10);
Vect_read_line(&In, Points, Cats, i);
fprintf(fpsvg, " <path ");
if (Cats->n_cats > 0) {
mk_attribs(Cats->cat[0], Fi, Driver, Table,
attr_cols, attr_size, do_attr);
}
fprintf(fpsvg, "d=\"");
mk_path(Points, precision);
fprintf(fpsvg, "\" />\n");
cnt += 1;
}
fprintf(fpsvg, " </g>\n");
G_message(_("Extracted %d lines"), cnt);
}
}
/* finish code */
fprintf(fpsvg, "</svg>\n");
if (db_open == 1) {
/* close database handle */
db_close_database(Driver);
db_shutdown_driver(Driver);
}
/* close SVG-file */
fclose(fpsvg);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
