OGRGRASSLayer::~OGRGRASSLayer()
{
if ( bCursorOpened )
{
db_close_cursor ( poCursor);
}
if ( poDriver )
{
StopDbDriver();
}
if ( pszName ) CPLFree ( pszName );
if ( poFeatureDefn )
poFeatureDefn->Release();
if ( poSRS )
poSRS->Release();
if ( pszQuery ) CPLFree ( pszQuery );
if ( paFeatureIndex ) CPLFree ( paFeatureIndex );
if ( poLink ) CPLFree ( poLink );
Vect_destroy_line_struct ( poPoints );
Vect_destroy_cats_struct ( poCats );
db_free_string ( poDbString );
CPLFree ( poDbString );
CPLFree ( poCursor );
if ( paSpatialMatch ) CPLFree ( paSpatialMatch );
if ( paQueryMatch ) CPLFree ( paQueryMatch );
}
/** Get the lines and boundaries from the map and load them in an array
*/
void load_lines(struct Map_info *map, struct Point **points, int *num_points,
struct Line **lines, int *num_lines)
{
int index_line = 0;
int index_point = 0;
struct line_pnts *sites;
struct line_cats *cats;
int cat = 0;
int type;
sites = Vect_new_line_struct();
cats = Vect_new_cats_struct();
while ((type = Vect_read_next_line(map, sites, cats)) > -1) {
if (type != GV_LINE && type != GV_BOUNDARY && type != GV_POINT)
continue;
if (type == GV_LINE)
process_line(sites, points, &index_point, lines, &index_line, -1);
else if (type == GV_BOUNDARY)
process_boundary(sites, points, &index_point, lines, &index_line,
cat++);
else if (type == GV_POINT)
process_point(sites, points, &index_point, -1);
}
*num_points = index_point;
*num_lines = index_line;
Vect_destroy_line_struct(sites);
Vect_destroy_cats_struct(cats);
}
/**
* \brief Create network arcs (edge) based on given point vector map (nodes)
*
* \param file input file defining arcs
* \param Points input vector point map
* \param Out output vector map
* \param afield arcs layer
* \param nfield nodes layer
*
* \return number of new arcs
*/
int create_arcs(FILE * file, struct Map_info *Pnts,
struct Map_info *Out, int afield, int nfield)
{
char buff[1024];
int lcat, fcat, tcat;
int node1, node2;
int narcs;
struct line_pnts *points, *points2;
struct line_cats *cats;
points = Vect_new_line_struct();
points2 = Vect_new_line_struct();
points = Vect_new_line_struct();
cats = Vect_new_cats_struct();
narcs = 0;
while (G_getl2(buff, sizeof(buff) - 1, file)) {
if (sscanf(buff, "%d%d%d", &lcat, &fcat, &tcat) != 3)
G_fatal_error(_("Error reading file: '%s'"), buff);
node1 = find_node(Pnts, afield, fcat);
node2 = find_node(Pnts, afield, tcat);
if (node1 < 1 || node2 < 1) {
G_warning(_("Skipping arc %d"), lcat);
continue;
}
/* geometry */
Vect_read_line(Pnts, points, cats, node1);
field2n(cats, nfield);
Vect_write_line(Out, GV_POINT, points, cats);
Vect_read_line(Pnts, points2, cats, node2);
field2n(cats, nfield);
Vect_write_line(Out, GV_POINT, points2, cats);
Vect_append_points(points, points2, GV_FORWARD);
/* category */
Vect_reset_cats(cats);
Vect_cat_set(cats, afield, lcat);
Vect_write_line(Out, GV_LINE, points, cats);
narcs++;
}
Vect_destroy_line_struct(points);
Vect_destroy_cats_struct(cats);
return narcs;
}
/*!
\brief Get node cost
For each node in the map, finds the category of the point on it (if
there is any) and stores the value associated with this category in
the array node_costs. If there is no point with a category,
node_costs=0.
node_costs are multiplied by 1000000 and truncated to integers (as
is done in Vect_net_build_graph)
\param In pointer to Map_info structure
\param layer layer number
\param column name of column
\param[out] node_costs list of node costs
\returns 1 on success
\return 0 on failure
*/
int NetA_get_node_costs(struct Map_info *In, int layer, char *column,
int *node_costs)
{
int i, nlines, nnodes;
dbCatValArray vals;
struct line_cats *Cats;
struct line_pnts *Points;
dbDriver *driver;
struct field_info *Fi;
Fi = Vect_get_field(In, layer);
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);
nlines = Vect_get_num_lines(In);
nnodes = Vect_get_num_nodes(In);
Cats = Vect_new_cats_struct();
Points = Vect_new_line_struct();
for (i = 1; i <= nnodes; i++)
node_costs[i] = 0;
db_CatValArray_init(&vals);
if (db_select_CatValArray(driver, Fi->table, Fi->key, column, NULL, &vals)
== -1)
return 0;
for (i = 1; i <= nlines; i++) {
int type = Vect_read_line(In, Points, Cats, i);
if (type == GV_POINT) {
int node, cat;
double value;
if (!Vect_cat_get(Cats, layer, &cat))
continue;
Vect_get_line_nodes(In, i, &node, NULL);
if (db_CatValArray_get_value_double(&vals, cat, &value) == DB_OK)
node_costs[node] = value * 1000000.0;
}
}
Vect_destroy_cats_struct(Cats);
db_CatValArray_free(&vals);
db_close_database_shutdown_driver(driver);
return 1;
}
void scan_cats(const struct Map_info *Map, int field,
const char *style, const char *rules,
const struct FPRange *range, struct Colors *colors)
{
int ltype, lmin, lmax, cmin, cmax;
struct line_cats *Cats;
cmin = cmax = -1;
Cats = Vect_new_cats_struct();
G_message(_("Reading features..."));
while(TRUE) {
ltype = Vect_read_next_line(Map, NULL, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
if (ltype == -2)
break; /* EOF */
scan_layer(field, Cats, &lmin, &lmax);
if (cmin == -1 || lmin <= cmin)
cmin = lmin;
if (cmax == -1 || lmax >= cmax)
cmax = lmax;
}
if (range) {
if (range->min >= cmin && range->min <= cmax)
cmin = range->min;
else
G_warning(_("Min value (%d) is out of range %d,%d"),
(int) range->min, cmin, cmax);
if (range->max <= cmax && range->max >= cmin)
cmax = range->max;
else
G_warning(_("Max value (%d) is out of range %d,%d"),
(int) range->max, cmin, cmax);
}
if (style)
make_colors(colors, style, (DCELL) cmin, (DCELL) cmax, FALSE);
else if (rules) {
load_colors(colors, rules, (DCELL) cmin, (DCELL) cmax, FALSE);
}
Vect_destroy_cats_struct(Cats);
}
int rmdac(struct Map_info *Out, struct Map_info *Err)
{
int i, type, area, ndupl, nlines;
struct line_pnts *Points;
struct line_cats *Cats;
nlines = Vect_get_num_lines(Out);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
G_debug(1, "nlines = %d", nlines);
ndupl = 0;
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 2);
if (!Vect_line_alive(Out, i))
continue;
type = Vect_read_line(Out, Points, Cats, i);
if (!(type & GV_CENTROID))
continue;
area = Vect_get_centroid_area(Out, i);
G_debug(3, " area = %d", area);
if (area < 0) {
Vect_delete_line(Out, i);
ndupl++;
if (Err) {
Vect_write_line(Err, type, Points, Cats);
}
}
}
G_verbose_message(_("Duplicate area centroids: %d"), ndupl);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return ndupl;
}
bool QgsGrassFeatureIterator::close()
{
if ( mClosed )
return false;
// finalization
Vect_destroy_line_struct( mPoints );
Vect_destroy_cats_struct( mCats );
Vect_destroy_list( mList );
free( mSelection );
// tell provider that this iterator is not active anymore
P->mActiveIterator = 0;
mClosed = true;
return true;
}
bool QgsGrassFeatureIterator::close()
{
if ( mClosed )
return false;
iteratorClosed();
// finalization
Vect_destroy_line_struct( mPoints );
Vect_destroy_cats_struct( mCats );
Vect_destroy_list( mList );
free( mSelection );
sMutex.unlock();
mClosed = true;
return true;
}
/*
Write a vector geometry to the output GRASS vector map.
Write attributes to table linked to that map. Link vector object to attribute
table record.
*/
void write_vect( int cat, int skelID, int boneID, int unitID,
double *xpnts, double *ypnts, double *zpnts,
int arr_size, int type )
{
struct line_cats *Cats;
struct line_pnts *Points;
char buf[MAXSTR];
char rgbbuf[12];
char rgbbuf2[12];
/* copy xyzpnts to Points */
Points = Vect_new_line_struct();
Vect_copy_xyz_to_pnts(Points, xpnts, ypnts, zpnts, arr_size);
/* write database attributes */
Cats = Vect_new_cats_struct();
sprintf ( rgbbuf, "%i:%i:%i", RGB[RGBNUM][0], RGB[RGBNUM][1], RGB[RGBNUM][2] );
sprintf ( rgbbuf2, "%i:%i:%i", RGB[RGB_MAPPER_COLOUR[boneID-1]][0],RGB[RGB_MAPPER_COLOUR[boneID-1]][1], RGB[RGB_MAPPER_COLOUR[boneID-1]][2] );
sprintf(buf, "insert into %s (cat, skel_id, bone_id, unit_id, GRASSRGB, BONERGB) values(%i,%i,%i,%i,'%s','%s');",
Fi->table, cat, skelID, boneID, unitID, rgbbuf, rgbbuf2);
if ( DEBUG ) {
fprintf ( stderr, "Writing attribute: %s\n", buf );
}
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to insert new record: %s"), db_get_string(&sql));
}
db_free_string(&sql);
Vect_cat_set(Cats, 1, cat);
/* write */
Vect_write_line(Map, type, Points, Cats);
Vect_destroy_cats_struct(Cats);
Vect_destroy_line_struct(Points);
}
/** counts the number of individual segments ( boundaries and lines ) and vertices
*/
void count(struct Map_info *map, int *num_points, int *num_lines)
{
int index_line = 0;
int index_point = 0;
struct line_pnts *sites;
struct line_cats *cats;
int type, i;
sites = Vect_new_line_struct();
cats = Vect_new_cats_struct();
for (i = 1; i <= map->plus.n_lines; i++) {
type = Vect_read_line(map, sites, cats, i);
if (type != GV_LINE && type != GV_BOUNDARY && type != GV_POINT)
continue;
if (type == GV_LINE) {
index_point += sites->n_points;
index_line += sites->n_points - 1;
}
else if (type == GV_BOUNDARY) {
index_point += sites->n_points - 1;
index_line += sites->n_points - 1;
}
else if (type == GV_POINT) {
index_point++;
}
}
*num_points = index_point;
*num_lines = index_line;
Vect_destroy_line_struct(sites);
Vect_destroy_cats_struct(cats);
}
/** add the edge pq to the map out
*/
void report(struct Point *p, struct Point *q, struct Map_info *out)
{
struct line_pnts *sites;
struct line_cats *cats;
double *tmpx = G_malloc(2 * sizeof(double));
double *tmpy = G_malloc(2 * sizeof(double));
sites = Vect_new_line_struct();
cats = Vect_new_cats_struct();
tmpx[0] = p->x;
tmpx[1] = q->x;
tmpy[0] = p->y;
tmpy[1] = q->y;
Vect_copy_xyz_to_pnts(sites, tmpx, tmpy, 0, 2);
Vect_write_line(out, GV_LINE, sites, cats);
Vect_destroy_line_struct(sites);
Vect_destroy_cats_struct(cats);
G_free(tmpx);
G_free(tmpy);
}
int edit_line_end(void *closure)
{
struct edit_line *el = closure;
if (el->phase > 1) {
if (el->reversed)
Vect_line_reverse(el->Points);
if (el->Points->n_points > 1) {
Vect_rewrite_line(&Map, el->line, el->line_type, el->Points,
el->Cats);
updated_lines_and_nodes_erase_refresh_display();
}
else {
int i;
/* delete lines with less than two points */
Vect_delete_line(&Map, el->line);
for (i = 0; i < el->Cats->n_cats; i++) {
check_record(el->Cats->field[i], el->Cats->cat[i]);
}
}
Vect_destroy_line_struct(el->Points);
Vect_destroy_cats_struct(el->Cats);
}
i_prompt("");
i_prompt_buttons("", "", "");
i_coor(COOR_NULL, COOR_NULL);
G_debug(3, "edit_line(): End");
return 1;
}
/* Returns 0 - ok , 1 - error */
int
plot(int ctype, struct Map_info *Map, int type, int field,
char *columns, int ncols, char *sizecol, int size, double scale,
COLOR * ocolor, COLOR * colors, int y_center, double *max_reference,
int do3d)
{
int ltype, nlines, line, col, more, coltype, nselcols;
double x, y, csize, len;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
double *val;
char buf[2000];
struct field_info *Fi;
dbDriver *driver;
dbValue *value;
dbString sql;
dbCursor cursor;
dbTable *table;
dbColumn *column;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
Fi = Vect_get_field(Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
/* Open driver */
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;
}
db_set_error_handler_driver(driver);
val = (double *)G_malloc((ncols + 1) * sizeof(double)); /* + 1 for sizecol */
Vect_rewind(Map);
nlines = Vect_get_num_lines(Map);
/* loop through each vector feature */
for (line = 1; line <= nlines; line++) {
G_debug(3, "line = %d", line);
ltype = Vect_read_line(Map, Points, Cats, line);
if (!(ltype & type))
continue;
Vect_cat_get(Cats, field, &cat);
if (cat < 0)
continue;
/* Select values from DB */
if (ctype == CTYPE_PIE && sizecol != NULL) {
sprintf(buf, "select %s, %s from %s where %s = %d", columns,
sizecol, Fi->table, Fi->key, cat);
nselcols = ncols + 1;
}
else {
sprintf(buf, "select %s from %s where %s = %d", columns,
Fi->table, Fi->key, cat);
nselcols = ncols;
}
db_set_string(&sql, buf);
G_debug(3, "SQL: %s", buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) !=
DB_OK) {
G_warning(_("Unable to open select cursor: '%s'"),
buf);
return 1;
}
table = db_get_cursor_table(&cursor);
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK || !more)
continue;
for (col = 0; col < nselcols; col++) {
column = db_get_table_column(table, col);
value = db_get_column_value(column);
coltype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
switch (coltype) {
case DB_C_TYPE_INT:
val[col] = (double)db_get_value_int(value);
break;
case DB_C_TYPE_DOUBLE:
val[col] = db_get_value_double(value);
break;
default:
G_warning("Column type not supported (must be INT or FLOAT)");
return 1;
}
G_debug(4, " val[%d]: %f", col, val[col]);
}
db_close_cursor(&cursor);
/* Center of chart */
if (ltype & GV_LINES) { /* find center */
len = Vect_line_length(Points) / 2;
Vect_point_on_line(Points, len, &x, &y, NULL, NULL, NULL);
}
else {
x = Points->x[0];
y = Points->y[0];
}
if (ctype == CTYPE_PIE) {
if (sizecol != NULL) {
csize = val[ncols];
size = scale * csize;
}
pie(x, y, size, val, ncols, ocolor, colors, do3d);
}
else {
bar(x, y, size, scale, val, ncols, ocolor, colors, y_center,
max_reference, do3d);
}
}
db_close_database_shutdown_driver(driver);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
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;
}
/*!
\brief transform 3d vector features to 2d (z-coordinate is omitted)
\param In input vector
\param Out output vector
\param type feature type to be transformed
\param field layer number
\param zcolumn attribute column where to store height
\return number of writen features
\return -1 on error
*/
int trans3d(struct Map_info *In, struct Map_info *Out, int type,
const char *field_name, const char *zcolumn)
{
int ltype, line;
int ctype;
int field;
struct line_pnts *Points;
struct line_cats *Cats;
struct field_info *Fi;
dbDriver *driver;
dbString stmt;
char buf[2000];
int ncats, *cats, cat, *cex;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&stmt);
field = Vect_get_field_number(In, field_name);
if (zcolumn) {
Fi = Vect_get_field(Out, field);
if (!Fi) {
G_warning(_("Database connection not defined for layer <%s>"),
field_name);
return -1;
}
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver) {
G_warning(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
return -1;
}
/* column type must numeric */
ctype = db_column_Ctype(driver, Fi->table, zcolumn);
if (ctype == -1) {
G_warning(_("Column <%s> not found in table <%s>"),
zcolumn, Fi->table);
return -1;
}
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE) {
G_warning(_("Column must be numeric"));
return -1;
}
db_begin_transaction(driver);
/* select existing categories (layer) to array (array is sorted) */
ncats = db_select_int(driver, Fi->table, Fi->key, NULL, &cats);
G_debug(3, "Existing categories: %d", ncats);
}
line = 1;
while (1) {
ltype = Vect_read_next_line(In, Points, Cats);
if (ltype == -1) {
G_warning(_("Unable to read vector map"));
return -1;
}
if (ltype == -2) { /* EOF */
break;
}
if (G_verbose() > G_verbose_min() && (line - 1) % 1000 == 0) {
fprintf(stderr, "%7d\b\b\b\b\b\b\b", (line - 1));
}
if (!(ltype & type))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, &cat))
continue;
/* get first cat */
if (cat == -1) {
G_warning(_("Feature id %d has no category - skipping"), line);
}
else if (Cats->n_cats > 1) {
G_warning(_("Feature id %d has more categories. "
"Using category %d."), line, field, cat);
}
if (zcolumn && ltype == GV_POINT && cat > -1) {
/* category exist in table ? */
cex = (int *)bsearch((void *)&cat, cats, ncats, sizeof(int),
srch);
/* store height to the attribute table */
if (ctype == DB_C_TYPE_INT)
sprintf(buf, "update %s set %s = %d where cat = %d",
Fi->table, zcolumn, (int)Points->z[0], cat);
else /* double */
sprintf(buf, "update %s set %s = %.8f where cat = %d",
Fi->table, zcolumn, Points->z[0], cat);
G_debug(3, "SQL: %s", buf);
db_set_string(&stmt, buf);
if (cex) {
if (db_execute_immediate(driver, &stmt) == DB_OK) {
/* TODO */
}
}
else { /* cat does not exist in table */
G_warning(_("Record (cat %d) does not exist (not updated)"),
cat);
}
}
Vect_write_line(Out, ltype, Points, Cats);
line++;
}
if (G_verbose() > G_verbose_min())
fprintf(stderr, "\r");
if (zcolumn) {
db_commit_transaction(driver);
G_free(cats);
db_close_database_shutdown_driver(driver);
db_free_string(&stmt);
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return line - 1;
}
/* *************************************************************** */
int plot1(struct Map_info *Map, int type, int area, struct cat_list *Clist,
const struct color_rgb *color, const struct color_rgb *fcolor,
int chcat, SYMBOL * Symb, int size, int id_flag,
int table_colors_flag, int cats_color_flag, char *rgb_column,
int default_width, char *width_column, double width_scale)
{
int i, ltype, nlines = 0, line, cat = -1;
double *x, *y;
struct line_pnts *Points, *PPoints;
struct line_cats *Cats;
double msize;
int x0, y0;
struct field_info *fi = NULL;
dbDriver *driver = NULL;
dbCatValArray cvarr_rgb, cvarr_width;
dbCatVal *cv_rgb = NULL, *cv_width = NULL;
int nrec_rgb = 0, nrec_width = 0;
int open_db;
int custom_rgb = FALSE;
char colorstring[12]; /* RRR:GGG:BBB */
int red, grn, blu;
RGBA_Color *line_color, *fill_color, *primary_color;
unsigned char which;
int width;
line_color = G_malloc(sizeof(RGBA_Color));
fill_color = G_malloc(sizeof(RGBA_Color));
primary_color = G_malloc(sizeof(RGBA_Color));
primary_color->a = RGBA_COLOR_OPAQUE;
/* change function prototype to pass RGBA_Color instead of color_rgb? */
if (color) {
line_color->r = color->r;
line_color->g = color->g;
line_color->b = color->b;
line_color->a = RGBA_COLOR_OPAQUE;
}
else
line_color->a = RGBA_COLOR_NONE;
if (fcolor) {
fill_color->r = fcolor->r;
fill_color->g = fcolor->g;
fill_color->b = fcolor->b;
fill_color->a = RGBA_COLOR_OPAQUE;
}
else
fill_color->a = RGBA_COLOR_NONE;
msize = size * (D_d_to_u_col(2.0) - D_d_to_u_col(1.0)); /* do it better */
Points = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
open_db = table_colors_flag || width_column;
if (open_db) {
fi = Vect_get_field(Map, (Clist->field > 0 ? Clist->field : 1));
if (fi == NULL) {
G_fatal_error(_("Database connection not defined for layer %d"),
(Clist->field > 0 ? Clist->field : 1));
}
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);
}
if (table_colors_flag) {
/* for reading RRR:GGG:BBB color strings from table */
if (rgb_column == NULL || *rgb_column == '\0')
G_fatal_error(_("Color definition column not specified"));
db_CatValArray_init(&cvarr_rgb);
nrec_rgb = db_select_CatValArray(driver, fi->table, fi->key,
rgb_column, NULL, &cvarr_rgb);
G_debug(3, "nrec_rgb (%s) = %d", rgb_column, nrec_rgb);
if (cvarr_rgb.ctype != DB_C_TYPE_STRING)
G_fatal_error(_("Color definition column (%s) not a string. "
"Column must be of form RRR:GGG:BBB where RGB values range 0-255."),
rgb_column);
if (nrec_rgb < 0)
G_fatal_error(_("Cannot select data (%s) from table"),
rgb_column);
G_debug(2, "\n%d records selected from table", nrec_rgb);
for (i = 0; i < cvarr_rgb.n_values; i++) {
G_debug(4, "cat = %d %s = %s", cvarr_rgb.value[i].cat,
rgb_column, db_get_string(cvarr_rgb.value[i].val.s));
}
}
if (width_column) {
if (*width_column == '\0')
G_fatal_error(_("Line width column not specified."));
db_CatValArray_init(&cvarr_width);
nrec_width = db_select_CatValArray(driver, fi->table, fi->key,
width_column, NULL, &cvarr_width);
G_debug(3, "nrec_width (%s) = %d", width_column, nrec_width);
if (cvarr_width.ctype != DB_C_TYPE_INT &&
cvarr_width.ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Line width column (%s) not a number."),
width_column);
if (nrec_width < 0)
G_fatal_error(_("Cannot select data (%s) from table"),
width_column);
G_debug(2, "\n%d records selected from table", nrec_width);
for (i = 0; i < cvarr_width.n_values; i++) {
G_debug(4, "cat = %d %s = %d", cvarr_width.value[i].cat,
width_column,
(cvarr_width.ctype ==
DB_C_TYPE_INT ? cvarr_width.value[i].val.
i : (int)cvarr_width.value[i].val.d));
}
}
if (open_db)
db_close_database_shutdown_driver(driver);
Vect_rewind(Map);
/* Is it necessary to reset line/label color in each loop ? */
if (color && !table_colors_flag && !cats_color_flag)
D_RGB_color(color->r, color->g, color->b);
if (Vect_level(Map) >= 2)
nlines = Vect_get_num_lines(Map);
line = 0;
while (1) {
if (Vect_level(Map) >= 2) {
line++;
if (line > nlines)
return 0;
if (!Vect_line_alive(Map, line))
continue;
ltype = Vect_read_line(Map, Points, Cats, line);
}
else {
ltype = Vect_read_next_line(Map, Points, Cats);
switch (ltype) {
case -1:
fprintf(stderr, _("\nERROR: vector map - can't read\n"));
return -1;
case -2: /* EOF */
return 0;
}
}
if (!(type & ltype))
continue;
if (chcat) {
int found = 0;
if (id_flag) { /* use line id */
if (!(Vect_cat_in_cat_list(line, Clist)))
continue;
}
else {
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = 1;
break;
}
}
if (!found)
continue;
}
}
else if (Clist->field > 0) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field) {
found = 1;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
if (table_colors_flag) {
/* only first category */
cat = Vect_get_line_cat(Map, line,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats >
0 ? Cats->field[0] : 1)));
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* Read RGB colors from db for current area # */
if (db_CatValArray_get_value(&cvarr_rgb, cat, &cv_rgb) !=
DB_OK) {
custom_rgb = FALSE;
}
else {
sprintf(colorstring, "%s", db_get_string(cv_rgb->val.s));
if (*colorstring != '\0') {
G_debug(3, "element %d: colorstring: %s", line,
colorstring);
if (G_str_to_color(colorstring, &red, &grn, &blu) ==
1) {
custom_rgb = TRUE;
G_debug(3, "element:%d cat %d r:%d g:%d b:%d",
line, cat, red, grn, blu);
}
else {
custom_rgb = FALSE;
G_warning(_("Error in color definition column (%s), element %d "
"with cat %d: colorstring [%s]"),
rgb_column, line, cat, colorstring);
}
}
else {
custom_rgb = FALSE;
G_warning(_("Error in color definition column (%s), element %d with cat %d"),
rgb_column, line, cat);
}
}
} /* end if cat */
else {
custom_rgb = FALSE;
}
} /* end if table_colors_flag */
/* random colors */
if (cats_color_flag) {
custom_rgb = FALSE;
if (Clist->field > 0) {
cat = Vect_get_line_cat(Map, line, Clist->field);
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* fetch color number from category */
which = (cat % palette_ncolors);
G_debug(3, "cat:%d which color:%d r:%d g:%d b:%d", cat,
which, palette[which].R, palette[which].G,
palette[which].B);
custom_rgb = TRUE;
red = palette[which].R;
grn = palette[which].G;
blu = palette[which].B;
}
}
else if (Cats->n_cats > 0) {
/* fetch color number from layer */
which = (Cats->field[0] % palette_ncolors);
G_debug(3, "layer:%d which color:%d r:%d g:%d b:%d",
Cats->field[0], which, palette[which].R,
palette[which].G, palette[which].B);
custom_rgb = TRUE;
red = palette[which].R;
grn = palette[which].G;
blu = palette[which].B;
}
}
if (nrec_width) {
/* only first category */
cat = Vect_get_line_cat(Map, line,
(Clist->field > 0 ? Clist->field :
(Cats->n_cats >
0 ? Cats->field[0] : 1)));
if (cat >= 0) {
G_debug(3, "display element %d, cat %d", line, cat);
/* Read line width from db for current area # */
if (db_CatValArray_get_value(&cvarr_width, cat, &cv_width) !=
DB_OK) {
width = default_width;
}
else {
width =
width_scale * (cvarr_width.ctype ==
DB_C_TYPE_INT ? cv_width->val.
i : (int)cv_width->val.d);
if (width < 0) {
G_warning(_("Error in line width column (%s), element %d "
"with cat %d: line width [%d]"),
width_column, line, cat, width);
width = default_width;
}
}
} /* end if cat */
else {
width = default_width;
}
D_line_width(width);
} /* end if nrec_width */
/* enough of the prep work, lets start plotting stuff */
x = Points->x;
y = Points->y;
if ((ltype & GV_POINTS) && Symb != NULL) {
if (!(color || fcolor || custom_rgb))
continue;
x0 = D_u_to_d_col(x[0]);
y0 = D_u_to_d_row(y[0]);
/* skip if the point is outside of the display window */
/* xy<0 tests make it go ever-so-slightly faster */
if (x0 < 0 || y0 < 0 ||
x0 > D_get_d_east() || x0 < D_get_d_west() ||
y0 > D_get_d_south() || y0 < D_get_d_north())
continue;
/* use random or RGB column color if given, otherwise reset */
/* centroids always use default color to stand out from underlying area */
if (custom_rgb && (ltype != GV_CENTROID)) {
primary_color->r = (unsigned char)red;
primary_color->g = (unsigned char)grn;
primary_color->b = (unsigned char)blu;
D_symbol2(Symb, x0, y0, primary_color, line_color);
}
else
D_symbol(Symb, x0, y0, line_color, fill_color);
}
else if (color || custom_rgb) {
if (!table_colors_flag && !cats_color_flag)
D_RGB_color(color->r, color->g, color->b);
else {
if (custom_rgb)
D_RGB_color((unsigned char)red, (unsigned char)grn,
(unsigned char)blu);
else
D_RGB_color(color->r, color->g, color->b);
}
/* Plot the lines */
if (Points->n_points == 1) /* line with one coor */
D_polydots_abs(x, y, Points->n_points);
else /*use different user defined render methods */
D_polyline_abs(x, y, Points->n_points);
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0; /* not reached */
}
int main(int argc, char *argv[])
{
struct Option *vector_opt, *seed_opt, *flowlines_opt, *flowacc_opt, *sampled_opt,
*scalar_opt, *unit_opt, *step_opt, *limit_opt, *skip_opt, *dir_opt,
*error_opt;
struct Flag *table_fl;
struct GModule *module;
RASTER3D_Region region;
RASTER3D_Map *flowacc, *sampled;
struct Integration integration;
struct Seed seed;
struct Gradient_info gradient_info;
struct Map_info seed_Map;
struct line_pnts *seed_points;
struct line_cats *seed_cats;
struct Map_info fl_map;
struct line_cats *fl_cats; /* for flowlines */
struct line_pnts *fl_points; /* for flowlines */
struct field_info *finfo;
dbDriver *driver;
int cat; /* cat of flowlines */
int if_table;
int i, r, c, d;
char *desc;
int n_seeds, seed_count, ltype;
int skip[3];
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("voxel"));
module->description =
_("Computes 3D flow lines and 3D flow accumulation.");
scalar_opt = G_define_standard_option(G_OPT_R3_INPUT);
scalar_opt->required = NO;
scalar_opt->guisection = _("Input");
vector_opt = G_define_standard_option(G_OPT_R3_INPUTS);
vector_opt->key = "vector_field";
vector_opt->required = NO;
vector_opt->description = _("Names of three 3D raster maps describing "
"x, y, z components of vector field");
vector_opt->guisection = _("Input");
seed_opt = G_define_standard_option(G_OPT_V_INPUT);
seed_opt->required = NO;
seed_opt->key = "seed_points";
seed_opt->description = _("If no map is provided, "
"flow lines are generated "
"from each cell of the input 3D raster");
seed_opt->label = _("Name of vector map with points "
"from which flow lines are generated");
seed_opt->guisection = _("Input");
flowlines_opt = G_define_standard_option(G_OPT_V_OUTPUT);
flowlines_opt->key = "flowline";
flowlines_opt->required = NO;
flowlines_opt->description = _("Name for vector map of flow lines");
flowlines_opt->guisection = _("Output");
flowacc_opt = G_define_standard_option(G_OPT_R3_OUTPUT);
flowacc_opt->key = "flowaccumulation";
flowacc_opt->required = NO;
flowacc_opt->description =
_("Name for output flowaccumulation 3D raster");
flowacc_opt->guisection = _("Output");
sampled_opt = G_define_standard_option(G_OPT_R3_INPUT);
sampled_opt->key = "sampled";
sampled_opt->required = NO;
sampled_opt->label =
_("Name for 3D raster sampled by flowlines");
sampled_opt->description =
_("Values of this 3D raster will be stored "
"as attributes of flowlines segments");
unit_opt = G_define_option();
unit_opt->key = "unit";
unit_opt->type = TYPE_STRING;
unit_opt->required = NO;
unit_opt->answer = "cell";
unit_opt->options = "time,length,cell";
desc = NULL;
G_asprintf(&desc,
"time;%s;"
"length;%s;"
"cell;%s",
_("elapsed time"),
_("length in map units"), _("length in cells (voxels)"));
unit_opt->descriptions = desc;
unit_opt->label = _("Unit of integration step");
unit_opt->description = _("Default unit is cell");
unit_opt->guisection = _("Integration");
step_opt = G_define_option();
step_opt->key = "step";
step_opt->type = TYPE_DOUBLE;
step_opt->required = NO;
step_opt->answer = "0.25";
step_opt->label = _("Integration step in selected unit");
step_opt->description = _("Default step is 0.25 cell");
step_opt->guisection = _("Integration");
limit_opt = G_define_option();
limit_opt->key = "limit";
limit_opt->type = TYPE_INTEGER;
limit_opt->required = NO;
limit_opt->answer = "2000";
limit_opt->description = _("Maximum number of steps");
limit_opt->guisection = _("Integration");
error_opt = G_define_option();
error_opt->key = "max_error";
error_opt->type = TYPE_DOUBLE;
error_opt->required = NO;
error_opt->answer = "1e-5";
error_opt->label = _("Maximum error of integration");
error_opt->description = _("Influences step, increase maximum error "
"to allow bigger steps");
error_opt->guisection = _("Integration");
skip_opt = G_define_option();
skip_opt->key = "skip";
skip_opt->type = TYPE_INTEGER;
skip_opt->required = NO;
skip_opt->multiple = YES;
skip_opt->description =
_("Number of cells between flow lines in x, y and z direction");
dir_opt = G_define_option();
dir_opt->key = "direction";
dir_opt->type = TYPE_STRING;
dir_opt->required = NO;
dir_opt->multiple = NO;
dir_opt->options = "up,down,both";
dir_opt->answer = "down";
dir_opt->description = _("Compute flowlines upstream, "
"downstream or in both direction.");
table_fl = G_define_flag();
table_fl->key = 'a';
table_fl->description = _("Create and fill attribute table");
G_option_required(scalar_opt, vector_opt, NULL);
G_option_exclusive(scalar_opt, vector_opt, NULL);
G_option_required(flowlines_opt, flowacc_opt, NULL);
G_option_requires(seed_opt, flowlines_opt, NULL);
G_option_requires(table_fl, flowlines_opt, NULL);
G_option_requires(sampled_opt, table_fl, NULL);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
driver = NULL;
finfo = NULL;
if_table = table_fl->answer ? TRUE : FALSE;
check_vector_input_maps(vector_opt, seed_opt);
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/* set up integration variables */
if (step_opt->answer) {
integration.step = atof(step_opt->answer);
integration.unit = unit_opt->answer;
}
else {
integration.unit = "cell";
integration.step = 0.25;
}
integration.max_error = atof(error_opt->answer);
integration.max_step = 5 * integration.step;
integration.min_step = integration.step / 5;
integration.limit = atof(limit_opt->answer);
if (strcmp(dir_opt->answer, "up") == 0)
integration.direction_type = FLOWDIR_UP;
else if (strcmp(dir_opt->answer, "down") == 0)
integration.direction_type = FLOWDIR_DOWN;
else
integration.direction_type = FLOWDIR_BOTH;
/* cell size is the diagonal */
integration.cell_size = sqrt(region.ns_res * region.ns_res +
region.ew_res * region.ew_res +
region.tb_res * region.tb_res);
/* set default skip if needed */
if (skip_opt->answers) {
for (i = 0; i < 3; i++) {
if (skip_opt->answers[i] != NULL) {
skip[i] = atoi(skip_opt->answers[i]);
}
else {
G_fatal_error(_("Please provide 3 integer values for skip option."));
}
}
}
else {
skip[0] = fmax(1, region.cols / 10);
skip[1] = fmax(1, region.rows / 10);
skip[2] = fmax(1, region.depths / 10);
}
/* open raster 3D maps of velocity components */
gradient_info.initialized = FALSE;
load_input_raster3d_maps(scalar_opt, vector_opt, &gradient_info, ®ion);
/* open new 3D raster map of flowacumulation */
if (flowacc_opt->answer) {
flowacc = Rast3d_open_new_opt_tile_size(flowacc_opt->answer,
RASTER3D_USE_CACHE_DEFAULT,
®ion, FCELL_TYPE, 32);
if (!flowacc)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
flowacc_opt->answer);
init_flowaccum(®ion, flowacc);
}
/* open 3D raster map used for sampling */
if (sampled_opt->answer) {
sampled = Rast3d_open_cell_old(sampled_opt->answer,
G_find_raster3d(sampled_opt->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (!sampled)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
sampled_opt->answer);
}
else
sampled = NULL;
/* open new vector map of flowlines */
if (flowlines_opt->answer) {
fl_cats = Vect_new_cats_struct();
fl_points = Vect_new_line_struct();
if (Vect_open_new(&fl_map, flowlines_opt->answer, TRUE) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
flowlines_opt->answer);
Vect_hist_command(&fl_map);
if (if_table) {
create_table(&fl_map, &finfo, &driver,
gradient_info.compute_gradient, sampled ? 1 : 0);
}
}
n_seeds = 0;
/* open vector map of seeds */
if (seed_opt->answer) {
if (Vect_open_old2(&seed_Map, seed_opt->answer, "", "1") < 0)
G_fatal_error(_("Unable to open vector map <%s>"),
seed_opt->answer);
if (!Vect_is_3d(&seed_Map))
G_fatal_error(_("Vector map <%s> is not 3D"), seed_opt->answer);
n_seeds = Vect_get_num_primitives(&seed_Map, GV_POINT);
}
if (flowacc_opt->answer || (!seed_opt->answer && flowlines_opt->answer)) {
if (flowacc_opt->answer)
n_seeds += region.cols * region.rows * region.depths;
else {
n_seeds += ceil(region.cols / (double)skip[0]) *
ceil(region.rows / (double)skip[1]) *
ceil(region.depths / (double)skip[2]);
}
}
G_debug(1, "Number of seeds is %d", n_seeds);
seed_count = 0;
cat = 1;
if (seed_opt->answer) {
seed_points = Vect_new_line_struct();
seed_cats = Vect_new_cats_struct();
/* compute flowlines from vector seed map */
while (TRUE) {
ltype = Vect_read_next_line(&seed_Map, seed_points, seed_cats);
if (ltype == -1) {
Vect_close(&seed_Map);
G_fatal_error(_("Error during reading seed vector map"));
}
else if (ltype == -2) {
break;
}
else if (ltype == GV_POINT) {
seed.x = seed_points->x[0];
seed.y = seed_points->y[0];
seed.z = seed_points->z[0];
seed.flowline = TRUE;
seed.flowaccum = FALSE;
}
G_percent(seed_count, n_seeds, 1);
if (integration.direction_type == FLOWDIR_UP ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_UP;
compute_flowline(®ion, &seed, &gradient_info, flowacc, sampled,
&integration, &fl_map, fl_cats, fl_points,
&cat, if_table, finfo, driver);
}
if (integration.direction_type == FLOWDIR_DOWN ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_DOWN;
compute_flowline(®ion, &seed, &gradient_info, flowacc, sampled,
&integration, &fl_map, fl_cats, fl_points,
&cat, if_table, finfo, driver);
}
seed_count++;
}
Vect_destroy_line_struct(seed_points);
Vect_destroy_cats_struct(seed_cats);
Vect_close(&seed_Map);
}
if (flowacc_opt->answer || (!seed_opt->answer && flowlines_opt->answer)) {
/* compute flowlines from points on grid */
for (r = region.rows; r > 0; r--) {
for (c = 0; c < region.cols; c++) {
for (d = 0; d < region.depths; d++) {
seed.x =
region.west + c * region.ew_res + region.ew_res / 2;
seed.y =
region.south + r * region.ns_res - region.ns_res / 2;
seed.z =
region.bottom + d * region.tb_res + region.tb_res / 2;
seed.flowline = FALSE;
seed.flowaccum = FALSE;
if (flowacc_opt->answer)
seed.flowaccum = TRUE;
if (flowlines_opt->answer && !seed_opt->answer &&
(c % skip[0] == 0) && (r % skip[1] == 0) && (d % skip[2] == 0))
seed.flowline = TRUE;
if (seed.flowaccum || seed.flowline) {
G_percent(seed_count, n_seeds, 1);
if (integration.direction_type == FLOWDIR_UP ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_UP;
compute_flowline(®ion, &seed, &gradient_info,
flowacc, sampled, &integration, &fl_map,
fl_cats, fl_points, &cat,
if_table, finfo, driver);
}
if (integration.direction_type == FLOWDIR_DOWN ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_DOWN;
compute_flowline(®ion, &seed, &gradient_info,
flowacc, sampled, &integration, &fl_map,
fl_cats, fl_points, &cat,
if_table, finfo, driver);
}
seed_count++;
}
}
}
}
}
G_percent(1, 1, 1);
if (flowlines_opt->answer) {
if (if_table) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_destroy_line_struct(fl_points);
Vect_destroy_cats_struct(fl_cats);
Vect_build(&fl_map);
Vect_close(&fl_map);
}
if (flowacc_opt->answer)
Rast3d_close(flowacc);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int line;
struct line_pnts *points;
struct line_cats *Cats;
struct Map_info map, Out;
struct GModule *module;
struct Option *input;
struct Option *output;
struct Option *cats;
struct Option *type_opt;
char *desc;
int polyline;
int *lines_visited;
int points_in_polyline;
int start_line;
int nlines;
int write_cats, copy_tables;
int type, ltype;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("topology"));
G_add_keyword(_("geometry"));
G_add_keyword(_("line"));
G_add_keyword(_("node"));
G_add_keyword(_("vertex"));
module->description = _("Builds polylines from lines or boundaries.");
/* Define the options */
input = G_define_standard_option(G_OPT_V_INPUT);
output = G_define_standard_option(G_OPT_V_OUTPUT);
cats = G_define_option();
cats->key = "cats";
cats->type = TYPE_STRING;
cats->description = _("Category number mode");
cats->options = "no,first,multi,same";
desc = NULL;
G_asprintf(&desc,
"no;%s;first;%s;multi;%s;same;%s",
_("Do not assign any category number to polyline"),
_("Assign category number of first line to polyline"),
_("Assign multiple category numbers to polyline"),
_("Create polyline from lines with same categories"));
cats->descriptions = desc;
cats->answer = "no";
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary";
type_opt->answer = "line,boundary";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Vect_check_input_output_name(input->answer, output->answer,
G_FATAL_EXIT);
/* Open binary vector map at level 2 */
Vect_set_open_level(2);
if (Vect_open_old(&map, input->answer, "") < 0)
G_fatal_error(_("Unable to open vector map <%s>"), input->answer);
/* Open new vector */
G_find_vector2(output->answer, "");
if (Vect_open_new(&Out, output->answer, Vect_is_3d(&map)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
/* Copy header info. */
Vect_copy_head_data(&map, &Out);
/* History */
Vect_hist_copy(&map, &Out);
Vect_hist_command(&Out);
/* Get the number of lines in the binary map and set up record of lines visited */
lines_visited =
(int *)G_calloc(Vect_get_num_lines(&map) + 1, sizeof(int));
/* Set up points structure and coordinate arrays */
points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* Write cats */
if (strcmp(cats->answer, "no") == 0)
write_cats = NO_CATS;
else if (strcmp(cats->answer, "first") == 0)
write_cats = ONE_CAT;
else
write_cats = MULTI_CATS;
if (type_opt->answer)
type = Vect_option_to_types(type_opt);
else
type = GV_LINES;
/* Step over all lines in binary map */
polyline = 0;
nlines = 0;
copy_tables = (write_cats != NO_CATS);
for (line = 1; line <= Vect_get_num_lines(&map); line++) {
Vect_reset_cats(Cats);
ltype = Vect_read_line(&map, NULL, NULL, line);
if ((ltype & GV_LINES) && (ltype & type))
nlines++;
else {
/* copy points to output as they are, with cats */
Vect_read_line(&map, points, Cats, line);
Vect_write_line(&Out, ltype, points, Cats);
if (Cats->n_cats > 0)
copy_tables = 1;
continue;
}
/* Skip line if already visited from another */
if (lines_visited[line])
continue;
/* Only get here if line is not previously visited */
/* Find start of this polyline */
start_line = walk_back(&map, line, ltype);
G_debug(1, "Polyline %d: start line = %d", polyline, start_line);
/* Walk forward and pick up coordinates */
points_in_polyline =
walk_forward_and_pick_up_coords(&map, start_line, ltype, points,
lines_visited, Cats, write_cats);
/* Write the line (type of the first line is used) */
Vect_write_line(&Out, ltype, points, Cats);
polyline++;
}
G_verbose_message(n_("%d line or boundaries found in input vector map",
"%d lines or boundaries found in input vector map",
nlines),
nlines, Vect_get_name(&map), Vect_get_mapset(&map));
G_verbose_message(n_("%d polyline stored in output vector map",
"%d polylines stored in output vector map",
polyline),
polyline, Vect_get_name(&Out), Vect_get_mapset(&Out));
/* Copy (all linked) tables if needed */
if (copy_tables) {
if (Vect_copy_tables(&map, &Out, 0))
G_warning(_("Failed to copy attribute table to output map"));
}
/* Tidy up */
Vect_destroy_line_struct(points);
Vect_destroy_cats_struct(Cats);
G_free(lines_visited);
Vect_close(&map);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
/*!
\brief Copy all alive vector features from given layer of opened
vector map to another opened vector map
\param In input vector map
\param field layer number (-1 for all layers)
\param[out] Out output vector map
\return 0 on success
\return 1 on error
*/
int Vect_copy_map_lines_field(struct Map_info *In, int field,
struct Map_info *Out)
{
int i, type, nlines, ret, left, rite, centroid;
struct line_pnts *Points, *CPoints;
struct line_cats *Cats, *CCats;
Points = Vect_new_line_struct();
CPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
CCats = Vect_new_cats_struct();
if (Vect_level(In) < 1)
G_fatal_error("Vect_copy_map_lines(): %s",
_("input vector map is not open"));
ret = 0;
/* Note: sometimes is important to copy on level 2 (pseudotopo centroids)
* and sometimes on level 1 if build take too long time */
if (Vect_level(In) >= 2) {
nlines = Vect_get_num_lines(In);
for (i = 1; i <= nlines; i++) {
if (!Vect_line_alive(In, i))
continue;
type = Vect_read_line(In, Points, Cats, i);
if (type == -1) {
G_warning(_("Unable to read vector map <%s>"),
Vect_get_full_name(In));
ret = 1;
break;
}
if (type == 0)
continue; /* dead line */
/* don't skips boundaries if field != -1 */
if (field != -1) {
if (type & GV_BOUNDARY) {
if (Vect_cat_get(Cats, field, NULL) == 0) {
int skip_bndry = 1;
Vect_get_line_areas(In, i, &left, &rite);
if (left < 0)
left = Vect_get_isle_area(In, abs(left));
if (left > 0) {
if ((centroid =
Vect_get_area_centroid(In, left)) > 0) {
Vect_read_line(In, CPoints, CCats, centroid);
if (Vect_cat_get(CCats, field, NULL) != 0)
skip_bndry = 0;
}
}
if (skip_bndry) {
if (rite < 0)
rite = Vect_get_isle_area(In, abs(rite));
if (rite > 0) {
if ((centroid =
Vect_get_area_centroid(In, rite)) > 0) {
Vect_read_line(In, CPoints, CCats,
centroid);
if (Vect_cat_get(CCats, field, NULL) != 0)
skip_bndry = 0;
}
}
}
if (skip_bndry)
continue;
}
}
else if (Vect_cat_get(Cats, field, NULL) == 0)
continue; /* different layer */
}
Vect_write_line(Out, type, Points, Cats);
}
}
else { /* Level 1 */
Vect_rewind(In);
while (1) {
type = Vect_read_next_line(In, Points, Cats);
if (type == -1) {
G_warning(_("Unable to read vector map <%s>"),
Vect_get_full_name(In));
ret = 1;
break;
}
else if (type == -2) { /* EOF */
break;
}
else if (type == 0) { /* dead line */
continue;
}
/* don't skip boundaries if field != -1 */
if (field != -1 && !(type & GV_BOUNDARY) &&
Vect_cat_get(Cats, field, NULL) == 0)
continue; /* different layer */
Vect_write_line(Out, type, Points, Cats);
}
}
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(CPoints);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(CCats);
return ret;
}
/*!
\brief Build topology
\param Map vector map
\param build build level
\return 1 on success
\return 0 on error
*/
int Vect_build_nat(struct Map_info *Map, int build)
{
struct Plus_head *plus;
int i, s, type, line;
off_t offset;
int side, area;
struct line_cats *Cats;
struct P_line *Line;
struct P_area *Area;
struct bound_box box;
G_debug(3, "Vect_build_nat() build = %d", build);
plus = &(Map->plus);
if (build == plus->built)
return 1; /* Do nothing */
/* Check if upgrade or downgrade */
if (build < plus->built) {
/* -> downgrade */
Vect__build_downgrade(Map, build);
return 1;
}
/* -> upgrade */
if (!Points)
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
if (plus->built < GV_BUILD_BASE) {
int npoints, c;
/*
* We shall go through all primitives in coor file and add
* new node for each end point to nodes structure if the node
* with the same coordinates doesn't exist yet.
*/
/* register lines, create nodes */
Vect_rewind(Map);
G_message(_("Registering primitives..."));
i = 0;
npoints = 0;
while (TRUE) {
/* register line */
type = Vect_read_next_line(Map, Points, Cats);
/* Note: check for dead lines is not needed, because they
are skipped by V1_read_next_line() */
if (type == -1) {
G_warning(_("Unable to read vector map"));
return 0;
}
else if (type == -2) {
break;
}
G_progress(++i, 1e4);
npoints += Points->n_points;
offset = Map->head.last_offset;
G_debug(3, "Register line: offset = %lu", (unsigned long)offset);
dig_line_box(Points, &box);
line = dig_add_line(plus, type, Points, &box, offset);
if (line == 1)
Vect_box_copy(&(plus->box), &box);
else
Vect_box_extend(&(plus->box), &box);
/* Add all categories to category index */
if (build == GV_BUILD_ALL) {
for (c = 0; c < Cats->n_cats; c++) {
dig_cidx_add_cat(plus, Cats->field[c], Cats->cat[c],
line, type);
}
if (Cats->n_cats == 0) /* add field 0, cat 0 */
dig_cidx_add_cat(plus, 0, 0, line, type);
}
}
G_progress(1, 1);
G_message(_n("One primitive registered", "%d primitives registered", plus->n_lines), plus->n_lines);
G_message(_n("One vertex registered", "%d vertices registered", npoints), npoints);
plus->built = GV_BUILD_BASE;
}
if (build < GV_BUILD_AREAS)
return 1;
if (plus->built < GV_BUILD_AREAS) {
/* Build areas */
/* Go through all bundaries and try to build area for both sides */
G_important_message(_("Building areas..."));
for (line = 1; line <= plus->n_lines; line++) {
G_percent(line, plus->n_lines, 1);
/* build */
if (plus->Line[line] == NULL) {
continue;
} /* dead line */
Line = plus->Line[line];
if (Line->type != GV_BOUNDARY) {
continue;
}
for (s = 0; s < 2; s++) {
if (s == 0)
side = GV_LEFT;
else
side = GV_RIGHT;
G_debug(3, "Build area for line = %d, side = %d", line, side);
Vect_build_line_area(Map, line, side);
}
}
G_message(_n("One area built", "%d areas built", plus->n_areas), plus->n_areas);
G_message(_n("One isle built", "%d isles built", plus->n_isles), plus->n_isles);
plus->built = GV_BUILD_AREAS;
}
if (build < GV_BUILD_ATTACH_ISLES)
return 1;
/* Attach isles to areas */
if (plus->built < GV_BUILD_ATTACH_ISLES) {
G_important_message(_("Attaching islands..."));
for (i = 1; i <= plus->n_isles; i++) {
G_percent(i, plus->n_isles, 1);
Vect_attach_isle(Map, i);
}
plus->built = GV_BUILD_ATTACH_ISLES;
}
if (build < GV_BUILD_CENTROIDS)
return 1;
/* Attach centroids to areas */
if (plus->built < GV_BUILD_CENTROIDS) {
int nlines;
struct P_topo_c *topo;
G_important_message(_("Attaching centroids..."));
nlines = Vect_get_num_lines(Map);
for (line = 1; line <= nlines; line++) {
G_percent(line, nlines, 1);
Line = plus->Line[line];
if (!Line)
continue; /* Dead */
if (Line->type != GV_CENTROID)
continue;
Vect_read_line(Map, Points, NULL, line);
area = Vect_find_area(Map, Points->x[0], Points->y[0]);
if (area > 0) {
G_debug(3, "Centroid (line=%d) in area %d", line, area);
Area = plus->Area[area];
topo = (struct P_topo_c *)Line->topo;
if (Area->centroid == 0) { /* first */
Area->centroid = line;
topo->area = area;
}
else { /* duplicate */
topo->area = -area;
}
}
}
plus->built = GV_BUILD_CENTROIDS;
}
/* Add areas to category index */
for (i = 1; i <= plus->n_areas; i++) {
int c;
if (plus->Area[i] == NULL)
continue;
if (plus->Area[i]->centroid > 0) {
Vect_read_line(Map, NULL, Cats, plus->Area[i]->centroid);
for (c = 0; c < Cats->n_cats; c++) {
dig_cidx_add_cat(plus, Cats->field[c], Cats->cat[c], i,
GV_AREA);
}
}
if (plus->Area[i]->centroid == 0 || Cats->n_cats == 0) /* no centroid or no cats */
dig_cidx_add_cat(plus, 0, 0, i, GV_AREA);
}
Vect_destroy_cats_struct(Cats);
return 1;
}
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;
}
int export_areas_multi(struct Map_info *In, int field, int donocat,
OGRFeatureDefnH Ogr_featuredefn,OGRLayerH Ogr_layer,
struct field_info *Fi, dbDriver *driver, int ncol, int *colctype,
const char **colname, int doatt, int nocat,
int *n_noatt, int *n_nocat)
{
int i, n_exported, area;
int cat, ncats_field, line, type, findex, ipart;
struct line_pnts *Points;
struct line_cats *Cats;
struct ilist *cat_list, *line_list, *lcats;
OGRGeometryH Ogr_geometry, Ogr_geometry_part;
OGRFeatureH Ogr_feature;
OGRwkbGeometryType wkbtype, wkbtype_part;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
cat_list = Vect_new_list();
line_list = Vect_new_list();
lcats = Vect_new_list();
n_exported = 0;
/* check if category index is available for given field */
findex = Vect_cidx_get_field_index(In, field);
if (findex == -1)
G_fatal_error(_("Unable to export multi-features. No category index for layer %d."),
field);
/* determine type */
wkbtype_part = wkbPolygon;
wkbtype = get_multi_wkbtype(wkbtype_part);
ncats_field = Vect_cidx_get_unique_cats_by_index(In, findex, cat_list);
G_debug(1, "n_cats = %d for layer %d", ncats_field, field);
if (donocat)
G_message(_("Exporting features with category..."));
for (i = 0; i < cat_list->n_values; i++) {
G_percent(i, cat_list->n_values - 1, 5);
cat = cat_list->value[i];
/* find all centroids with given category */
Vect_cidx_find_all(In, field, GV_CENTROID, cat, line_list);
/* create multi-feature */
Ogr_geometry = OGR_G_CreateGeometry(wkbtype);
/* build simple features geometry, go through all parts */
for (ipart = 0; ipart < line_list->n_values; ipart++) {
line = line_list->value[ipart];
G_debug(3, "cat=%d, line=%d -> part=%d", cat, line, ipart);
/* get centroid's category */
Vect_read_line(In, NULL, Cats, line);
/* check for category consistency */
Vect_field_cat_get(Cats, field, lcats);
if (!Vect_val_in_list(lcats, cat))
G_fatal_error(_("Unable to create multi-feature. "
"Category %d not found in line %d, field %d"),
cat, line, field);
/* find correspoding area */
area = Vect_get_centroid_area(In, line);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry_part = create_polygon(In, area, Points);
/* add part */
OGR_G_AddGeometryDirectly(Ogr_geometry, Ogr_geometry_part);
}
if (!OGR_G_IsEmpty(Ogr_geometry)) {
/* write multi-feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
OGR_F_Destroy(Ogr_feature);
n_exported++;
}
else {
/* skip empty features */
G_debug(3, "multi-feature is empty -> skipped");
}
OGR_G_DestroyGeometry(Ogr_geometry);
}
if (donocat)
G_message(_("Exporting features without category..."));
/* check lines without category, if -c flag is given write them as
* one multi-feature */
Ogr_geometry = OGR_G_CreateGeometry(wkbtype);
Vect_rewind(In);
Vect_set_constraint_type(In, GV_CENTROID);
while(TRUE) {
type = Vect_read_next_line(In, NULL, Cats);
if (type < 0)
break;
/* get centroid's category */
Vect_cat_get(Cats, field, &cat);
if (cat > 0)
continue; /* skip features with category */
if (cat < 0 && !donocat) {
(*n_nocat)++;
continue; /* skip lines without category, do not export
* not labeled */
}
/* find correspoding area */
line = Vect_get_next_line_id(In);
area = Vect_get_centroid_area(In, line);
if (area == 0)
continue;
/* create polygon from area */
Ogr_geometry_part = create_polygon(In, area, Points);
/* add part */
OGR_G_AddGeometryDirectly(Ogr_geometry, Ogr_geometry_part);
(*n_nocat)++;
}
if (!OGR_G_IsEmpty(Ogr_geometry)) {
/* write multi-feature */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
mk_att(cat, Fi, driver, ncol, colctype, colname, doatt, nocat,
Ogr_feature, n_noatt);
OGR_L_CreateFeature(Ogr_layer, Ogr_feature);
OGR_F_Destroy(Ogr_feature);
n_exported++;
}
else {
/* skip empty features */
G_debug(3, "multi-feature is empty -> skipped");
}
OGR_G_DestroyGeometry(Ogr_geometry);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
Vect_destroy_list(cat_list);
Vect_destroy_list(line_list);
Vect_destroy_list(lcats);
return n_exported;
}
/*!
\brief Split selected lines on given position
\param Map pointer to Map_info
\param List list of selected lines
\param coord points location
\param thresh threshold
\param[out] List_updated list of rewritten features (or NULL)
\return number of modified lines
\return -1 on error
*/
int Vedit_split_lines(struct Map_info *Map, struct ilist *List,
struct line_pnts *coord, double thresh,
struct ilist *List_updated)
{
int i, j, l;
int type, line, seg, newline;
int nlines_modified;
double px, py, spdist, lpdist, dist;
double *x, *y, *z;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
struct ilist *List_in_box;
nlines_modified = 0;
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
List_in_box = Vect_new_list();
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, Points, Cats, line);
if (!(type & GV_LINES))
continue;
x = Points->x;
y = Points->y;
z = Points->z;
for (j = 0; j < coord->n_points; j++) {
seg =
Vect_line_distance(Points, coord->x[j], coord->y[j],
coord->z[j], WITHOUT_Z, &px, &py, NULL,
&dist, &spdist, &lpdist);
if (dist > thresh) {
continue;
}
G_debug(3, "Vedit_split_lines(): line=%d, x=%f, y=%f, px=%f, py=%f, seg=%d, "
"dist=%f, spdist=%f, lpdist=%f", line, coord->x[j],
coord->y[j], px, py, seg, dist, spdist, lpdist);
if (spdist <= 0.0 || spdist >= Vect_line_length(Points))
continue;
G_debug(3, "Vedit_split_lines(): line=%d", line);
/* copy first line part */
for (l = 0; l < seg; l++) {
Vect_append_point(Points2, x[l], y[l], z[l]);
}
/* add last vertex */
Vect_append_point(Points2, px, py, 0.0);
/* rewrite the line */
newline = Vect_rewrite_line(Map, line, type, Points2, Cats);
if (newline < 0) {
return -1;
}
if (List_updated)
Vect_list_append(List_updated, newline);
Vect_reset_line(Points2);
/* add given vertex */
Vect_append_point(Points2, px, py, 0.0);
/* copy second line part */
for (l = seg; l < Points->n_points; l++) {
Vect_append_point(Points2, x[l], y[l], z[l]);
}
/* rewrite the line */
newline = Vect_write_line(Map, type, Points2, Cats);
if (newline < 0) {
return -1;
}
if (List_updated)
Vect_list_append(List_updated, newline);
nlines_modified++;
} /* for each bounding box */
} /* for each selected line */
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Points2);
Vect_destroy_cats_struct(Cats);
Vect_destroy_list(List_in_box);
return nlines_modified;
}
/*!
\brief Extensive tests for correct topology
- lines or boundaries of zero length
- intersecting boundaries, ie. overlapping areas
- areas without centroids that are not isles
\param Map vector map
\param[out] Err vector map where errors will be written or NULL
\return 1 on success
\return 0 on error
*/
int Vect_topo_check(struct Map_info *Map, struct Map_info *Err)
{
int line, nlines;
int nerrors, n_zero_lines, n_zero_boundaries;
struct line_pnts *Points;
struct line_cats *Cats;
/* rebuild topology if needed */
if (Vect_get_built(Map) != GV_BUILD_ALL) {
Vect_build_partial(Map, GV_BUILD_NONE);
Vect_build(Map);
}
G_message(_("Checking for topological errors..."));
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* lines or boundaries of zero length */
n_zero_lines = n_zero_boundaries = 0;
nlines = Vect_get_num_lines(Map);
for (line = 1; line <= nlines; line++) {
int type;
if (!Vect_line_alive(Map, line))
continue;
type = Vect_get_line_type(Map, line);
if (type & GV_LINES) {
double len;
Vect_read_line(Map, Points, Cats, line);
len = Vect_line_length(Points);
if (len == 0) {
if (type & GV_LINE)
n_zero_lines++;
else if (type & GV_BOUNDARY)
n_zero_boundaries++;
if (Err)
Vect_write_line(Err, type, Points, Cats);
}
}
}
if (n_zero_lines)
G_warning(_("Number of lines of length zero: %d"), n_zero_lines);
if (n_zero_boundaries)
G_warning(_("Number of boundaries of length zero: %d"), n_zero_boundaries);
/* remaining checks are for areas only */
if (Vect_get_num_primitives(Map, GV_BOUNDARY) == 0)
return 1;
/* intersecting boundaries -> overlapping areas */
nerrors = Vect_check_line_breaks(Map, GV_BOUNDARY, Err);
if (nerrors)
G_warning(_("Number of boundary intersections: %d"), nerrors);
/* areas without centroids that are not isles
* only makes sense if all boundaries are correct */
nerrors = 0;
for (line = 1; line <= nlines; line++) {
int type;
if (!Vect_line_alive(Map, line))
continue;
type = Vect_get_line_type(Map, line);
if (type == GV_BOUNDARY) {
struct P_topo_b *topo = (struct P_topo_b *)Map->plus.Line[line]->topo;
if (topo->left == 0 || topo->right == 0) {
G_debug(3, "line = %d left = %d right = %d", line,
topo->left, topo->right);
nerrors++;
}
}
}
if (nerrors)
G_warning(_("Skipping further checks because of incorrect boundaries"));
else {
int i, area, left, right, neighbour;
int nareas = Vect_get_num_areas(Map);
struct ilist *List = Vect_new_list();
nerrors = 0;
for (area = 1; area <= nareas; area++) {
if (!Vect_area_alive(Map, area))
continue;
line = Vect_get_area_centroid(Map, area);
if (line != 0)
continue; /* has centroid */
Vect_get_area_boundaries(Map, area, List);
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
Vect_get_line_areas(Map, abs(line), &left, &right);
if (line > 0)
neighbour = left;
else
neighbour = right;
if (neighbour < 0) {
neighbour = Vect_get_isle_area(Map, abs(neighbour));
if (!neighbour) {
/* borders outer void */
nerrors++;
if (Err) {
Vect_read_line(Map, Points, Cats, abs(line));
Vect_write_line(Err, GV_BOUNDARY, Points, Cats);
}
}
/* else neighbour is > 0, check below */
}
if (neighbour > 0) {
if (Vect_get_area_centroid(Map, neighbour) == 0) {
/* neighbouring area does not have a centroid either */
nerrors++;
if (Err) {
Vect_read_line(Map, Points, Cats, abs(line));
Vect_write_line(Err, GV_BOUNDARY, Points, Cats);
}
}
}
}
}
Vect_destroy_list(List);
if (nerrors)
G_warning(_("Number of redundant holes: %d"),
nerrors);
}
/* what else ? */
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 1;
}
/* break polygons using a file-based search index */
void Vect_break_polygons_file(struct Map_info *Map, int type, struct Map_info *Err)
{
struct line_pnts *BPoints, *Points;
struct line_cats *Cats, *ErrCats;
int i, j, k, ret, ltype, broken, last, nlines;
int nbreaks;
struct RTree *RTree;
int npoints, nallpoints, nmarks;
XPNT2 XPnt;
double dx, dy, a1 = 0, a2 = 0;
int closed, last_point;
char cross;
int fd, xpntfd;
char *filename;
static struct RTree_Rect rect;
static int rect_init = 0;
if (!rect_init) {
rect.boundary = G_malloc(6 * sizeof(RectReal));
rect_init = 6;
}
G_debug(1, "File-based version of Vect_break_polygons()");
filename = G_tempfile();
fd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
RTree = RTreeCreateTree(fd, 0, 2);
remove(filename);
filename = G_tempfile();
xpntfd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
remove(filename);
BPoints = Vect_new_line_struct();
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ErrCats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(Map);
G_debug(3, "nlines = %d", nlines);
/* Go through all lines in vector, and add each point to structure of points,
* if such point already exists check angles of segments and if differ mark for break */
nmarks = 0;
npoints = 1; /* index starts from 1 ! */
nallpoints = 0;
XPnt.used = 0;
G_message(_("Breaking polygons (pass 1: select break points)..."));
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
/* This would be confused by duplicate coordinates (angle cannot be calculated) ->
* prune line first */
Vect_line_prune(Points);
/* If first and last point are identical it is close polygon, we don't need to register last point
* and we can calculate angle for first.
* If first and last point are not identical we have to mark for break both */
last_point = Points->n_points - 1;
if (Points->x[0] == Points->x[last_point] &&
Points->y[0] == Points->y[last_point])
closed = 1;
else
closed = 0;
for (j = 0; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
if (j == last_point && closed)
continue; /* do not register last of close polygon */
/* Box */
rect.boundary[0] = Points->x[j];
rect.boundary[3] = Points->x[j];
rect.boundary[1] = Points->y[j];
rect.boundary[4] = Points->y[j];
rect.boundary[2] = 0;
rect.boundary[5] = 0;
/* Already in DB? */
fpoint = -1;
RTreeSearch(RTree, &rect, (void *)srch, NULL);
G_debug(3, "fpoint = %d", fpoint);
if (Points->n_points <= 2 ||
(!closed && (j == 0 || j == last_point))) {
cross = 1; /* mark for cross in any case */
}
else { /* calculate angles */
cross = 0;
if (j == 0 && closed) { /* closed polygon */
dx = Points->x[last_point] - Points->x[0];
dy = Points->y[last_point] - Points->y[0];
a1 = atan2(dy, dx);
dx = Points->x[1] - Points->x[0];
dy = Points->y[1] - Points->y[0];
a2 = atan2(dy, dx);
}
else {
dx = Points->x[j - 1] - Points->x[j];
dy = Points->y[j - 1] - Points->y[j];
a1 = atan2(dy, dx);
dx = Points->x[j + 1] - Points->x[j];
dy = Points->y[j + 1] - Points->y[j];
a2 = atan2(dy, dx);
}
}
if (fpoint > 0) { /* Found */
/* read point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
read(xpntfd, &XPnt, sizeof(XPNT2));
if (XPnt.cross == 1)
continue; /* already marked */
/* Check angles */
if (cross) {
XPnt.cross = 1;
nmarks++;
/* write point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
}
else {
G_debug(3, "a1 = %f xa1 = %f a2 = %f xa2 = %f", a1,
XPnt.a1, a2, XPnt.a2);
if ((a1 == XPnt.a1 && a2 == XPnt.a2) ||
(a1 == XPnt.a2 && a2 == XPnt.a1)) { /* identical */
}
else {
XPnt.cross = 1;
nmarks++;
/* write point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
}
}
}
else {
/* Add to tree and to structure */
RTreeInsertRect(&rect, npoints, RTree);
if (j == 0 || j == (Points->n_points - 1) ||
Points->n_points < 3) {
XPnt.a1 = 0;
XPnt.a2 = 0;
XPnt.cross = 1;
nmarks++;
}
else {
XPnt.a1 = a1;
XPnt.a2 = a2;
XPnt.cross = 0;
}
/* write point */
lseek(xpntfd, (off_t) (npoints - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
npoints++;
}
}
}
nbreaks = 0;
/* Second loop through lines (existing when loop is started, no need to process lines written again)
* and break at points marked for break */
G_message(_("Breaking polygons (pass 2: break at selected points)..."));
for (i = 1; i <= nlines; i++) {
int n_orig_points;
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
if (!(ltype & GV_LINES))
continue; /* Nonsense to break points */
/* Duplicates would result in zero length lines -> prune line first */
n_orig_points = Points->n_points;
Vect_line_prune(Points);
broken = 0;
last = 0;
G_debug(3, "n_points = %d", Points->n_points);
for (j = 1; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
/* Box */
rect.boundary[0] = Points->x[j];
rect.boundary[3] = Points->x[j];
rect.boundary[1] = Points->y[j];
rect.boundary[4] = Points->y[j];
rect.boundary[2] = 0;
rect.boundary[5] = 0;
if (Points->n_points <= 1 ||
(j == (Points->n_points - 1) && !broken))
break;
/* One point only or
* last point and line is not broken, do nothing */
RTreeSearch(RTree, &rect, (void *)srch, 0);
G_debug(3, "fpoint = %d", fpoint);
/* read point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
read(xpntfd, &XPnt, sizeof(XPNT2));
/* break or write last segment of broken line */
if ((j == (Points->n_points - 1) && broken) ||
XPnt.cross) {
Vect_reset_line(BPoints);
for (k = last; k <= j; k++) {
Vect_append_point(BPoints, Points->x[k], Points->y[k],
Points->z[k]);
}
/* Result may collapse to one point */
Vect_line_prune(BPoints);
if (BPoints->n_points > 1) {
ret = Vect_write_line(Map, ltype, BPoints, Cats);
G_debug(3,
"Line %d written j = %d n_points(orig,pruned) = %d n_points(new) = %d",
ret, j, Points->n_points, BPoints->n_points);
}
if (!broken)
Vect_delete_line(Map, i); /* not yet deleted */
/* Write points on breaks */
if (Err) {
if (XPnt.cross && !XPnt.used) {
Vect_reset_line(BPoints);
Vect_append_point(BPoints, Points->x[j], Points->y[j], 0);
Vect_write_line(Err, GV_POINT, BPoints, ErrCats);
}
if (!XPnt.used) {
XPnt.used = 1;
/* write point */
lseek(xpntfd, (off_t) (fpoint - 1) * sizeof(XPNT2), SEEK_SET);
write(xpntfd, &XPnt, sizeof(XPNT2));
}
}
last = j;
broken = 1;
nbreaks++;
}
}
if (!broken && n_orig_points > Points->n_points) { /* was pruned before -> rewrite */
if (Points->n_points > 1) {
Vect_rewrite_line(Map, i, ltype, Points, Cats);
G_debug(3, "Line %d pruned, npoints = %d", i,
Points->n_points);
}
else {
Vect_delete_line(Map, i);
G_debug(3, "Line %d was deleted", i);
}
}
else {
G_debug(3, "Line %d was not changed", i);
}
}
close(RTree->fd);
RTreeDestroyTree(RTree);
close(xpntfd);
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(BPoints);
Vect_destroy_cats_struct(Cats);
Vect_destroy_cats_struct(ErrCats);
G_verbose_message(_("Breaks: %d"), nbreaks);
}
void scan_z(struct Map_info *Map, int field,
const char *style, const char *rules,
const struct FPRange *range, struct Colors *colors)
{
int ltype, line, cat, i;
int items_alloc;
double zmin, zmax;
struct line_pnts *Points;
struct line_cats *Cats;
struct Colors vcolors;
dbCatValArray cvarr;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
items_alloc = 0;
db_CatValArray_init(&cvarr);
cvarr.ctype = DB_C_TYPE_DOUBLE;
Vect_set_constraint_field(Map, field);
Vect_set_constraint_type(Map, GV_POINTS); /* points, centroids or kernels only) */
G_message(_("Reading features..."));
line = i = 0;
while(TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
if (ltype == -2)
break; /* EOF */
G_progress(++line, 1e4);
if (Vect_cat_get(Cats, field, &cat) == -1)
continue; /* skip features without category */
/* add item into cat-value array */
if (i >= items_alloc) {
items_alloc += 1000;
db_CatValArray_realloc(&cvarr, items_alloc);
}
cvarr.n_values++;
cvarr.value[i].cat = cat;
cvarr.value[i++].val.d = Points->z[0];
if (line == 1 || Points->z[0] < zmin)
zmin = Points->z[0];
if (line == 1 || Points->z[0] > zmax)
zmax = Points->z[0];
}
G_progress(1, 1);
/* sort array by z-coordinate */
db_CatValArray_sort_by_value(&cvarr);
if (range) {
if (range->min >= zmin && range->min <= zmax)
zmin = range->min;
else
G_warning(_("Min value (%f) is out of range %f,%f"),
range->min, zmin, zmax);
if (range->max <= zmax && range->max >= zmin)
zmax = range->max;
else
G_warning(_("Max value (%f) is out of range %f,%f"),
range->max, zmin, zmax);
}
if (style)
make_colors(&vcolors, style, (DCELL) zmin, (DCELL) zmax, TRUE);
else if (rules) {
load_colors(&vcolors, rules, (DCELL) zmin, (DCELL) zmax, TRUE);
}
/* color table for categories */
color_rules_to_cats(&cvarr, TRUE, &vcolors, colors);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
db_CatValArray_free(&cvarr);
}
/* break polygons using a memory-based search index */
void Vect_break_polygons_mem(struct Map_info *Map, int type, struct Map_info *Err)
{
struct line_pnts *BPoints, *Points;
struct line_cats *Cats, *ErrCats;
int i, j, k, ret, ltype, broken, last, nlines;
int nbreaks;
struct RB_TREE *RBTree;
int npoints, nallpoints, nmarks;
XPNT *XPnt_found, XPnt_search;
double dx, dy, a1 = 0, a2 = 0;
int closed, last_point, cross;
G_debug(1, "Memory-based version of Vect_break_polygons()");
RBTree = rbtree_create(compare_xpnts, sizeof(XPNT));
BPoints = Vect_new_line_struct();
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
ErrCats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(Map);
G_debug(3, "nlines = %d", nlines);
/* Go through all lines in vector, and add each point to structure of points,
* if such point already exists check angles of segments and if differ mark for break */
nmarks = 0;
npoints = 0;
nallpoints = 0;
XPnt_search.used = 0;
G_message(_("Breaking polygons (pass 1: select break points)..."));
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
/* This would be confused by duplicate coordinates (angle cannot be calculated) ->
* prune line first */
Vect_line_prune(Points);
/* If first and last point are identical it is close polygon, we don't need to register last point
* and we can calculate angle for first.
* If first and last point are not identical we have to mark for break both */
last_point = Points->n_points - 1;
if (Points->x[0] == Points->x[last_point] &&
Points->y[0] == Points->y[last_point])
closed = 1;
else
closed = 0;
for (j = 0; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
if (j == last_point && closed)
continue; /* do not register last of close polygon */
XPnt_search.x = Points->x[j];
XPnt_search.y = Points->y[j];
/* Already in DB? */
XPnt_found = rbtree_find(RBTree, &XPnt_search);
if (Points->n_points <= 2 ||
(!closed && (j == 0 || j == last_point))) {
cross = 1; /* mark for cross in any case */
}
else { /* calculate angles */
cross = 0;
if (j == 0 && closed) { /* closed polygon */
dx = Points->x[last_point] - Points->x[0];
dy = Points->y[last_point] - Points->y[0];
a1 = atan2(dy, dx);
dx = Points->x[1] - Points->x[0];
dy = Points->y[1] - Points->y[0];
a2 = atan2(dy, dx);
}
else {
dx = Points->x[j - 1] - Points->x[j];
dy = Points->y[j - 1] - Points->y[j];
a1 = atan2(dy, dx);
dx = Points->x[j + 1] - Points->x[j];
dy = Points->y[j + 1] - Points->y[j];
a2 = atan2(dy, dx);
}
}
if (XPnt_found) { /* found */
if (XPnt_found->cross == 1)
continue; /* already marked */
/* check angles */
if (cross) {
XPnt_found->cross = 1;
nmarks++;
}
else {
G_debug(3, "a1 = %f xa1 = %f a2 = %f xa2 = %f", a1,
XPnt_found->a1, a2, XPnt_found->a2);
if ((a1 == XPnt_found->a1 && a2 == XPnt_found->a2) ||
(a1 == XPnt_found->a2 && a2 == XPnt_found->a1)) { /* identical */
}
else {
XPnt_found->cross = 1;
nmarks++;
}
}
}
else {
if (j == 0 || j == (Points->n_points - 1) ||
Points->n_points < 3) {
XPnt_search.a1 = 0;
XPnt_search.a2 = 0;
XPnt_search.cross = 1;
nmarks++;
}
else {
XPnt_search.a1 = a1;
XPnt_search.a2 = a2;
XPnt_search.cross = 0;
}
/* Add to tree */
rbtree_insert(RBTree, &XPnt_search);
npoints++;
}
}
}
nbreaks = 0;
nallpoints = 0;
G_debug(2, "Break polygons: unique vertices: %ld", (long int)RBTree->count);
/* uncomment to check if search tree is healthy */
/* if (rbtree_debug(RBTree, RBTree->root) == 0)
G_warning("Break polygons: RBTree not ok"); */
/* Second loop through lines (existing when loop is started, no need to process lines written again)
* and break at points marked for break */
G_message(_("Breaking polygons (pass 2: break at selected points)..."));
for (i = 1; i <= nlines; i++) {
int n_orig_points;
G_percent(i, nlines, 1);
G_debug(3, "i = %d", i);
if (!Vect_line_alive(Map, i))
continue;
ltype = Vect_read_line(Map, Points, Cats, i);
if (!(ltype & type))
continue;
if (!(ltype & GV_LINES))
continue; /* Nonsense to break points */
/* Duplicates would result in zero length lines -> prune line first */
n_orig_points = Points->n_points;
Vect_line_prune(Points);
broken = 0;
last = 0;
G_debug(3, "n_points = %d", Points->n_points);
for (j = 1; j < Points->n_points; j++) {
G_debug(3, "j = %d", j);
nallpoints++;
if (Points->n_points <= 1 ||
(j == (Points->n_points - 1) && !broken))
break;
/* One point only or
* last point and line is not broken, do nothing */
XPnt_search.x = Points->x[j];
XPnt_search.y = Points->y[j];
XPnt_found = rbtree_find(RBTree, &XPnt_search);
/* all points must be in the search tree, without duplicates */
if (XPnt_found == NULL)
G_fatal_error(_("Point not in search tree!"));
/* break or write last segment of broken line */
if ((j == (Points->n_points - 1) && broken) ||
XPnt_found->cross) {
Vect_reset_line(BPoints);
for (k = last; k <= j; k++) {
Vect_append_point(BPoints, Points->x[k], Points->y[k],
Points->z[k]);
}
/* Result may collapse to one point */
Vect_line_prune(BPoints);
if (BPoints->n_points > 1) {
ret = Vect_write_line(Map, ltype, BPoints, Cats);
G_debug(3,
"Line %d written j = %d n_points(orig,pruned) = %d n_points(new) = %d",
ret, j, Points->n_points, BPoints->n_points);
}
if (!broken)
Vect_delete_line(Map, i); /* not yet deleted */
/* Write points on breaks */
if (Err) {
if (XPnt_found->cross && !XPnt_found->used) {
Vect_reset_line(BPoints);
Vect_append_point(BPoints, Points->x[j], Points->y[j], 0);
Vect_write_line(Err, GV_POINT, BPoints, ErrCats);
}
XPnt_found->used = 1;
}
last = j;
broken = 1;
nbreaks++;
}
}
if (!broken && n_orig_points > Points->n_points) { /* was pruned before -> rewrite */
if (Points->n_points > 1) {
Vect_rewrite_line(Map, i, ltype, Points, Cats);
G_debug(3, "Line %d pruned, npoints = %d", i,
Points->n_points);
}
else {
Vect_delete_line(Map, i);
G_debug(3, "Line %d was deleted", i);
}
}
else {
G_debug(3, "Line %d was not changed", i);
}
}
rbtree_destroy(RBTree);
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(BPoints);
Vect_destroy_cats_struct(Cats);
G_verbose_message(_("Breaks: %d"), nbreaks);
}
/*!
\brief transform 2d vector features to 3d
\param In input vector
\param Out output vector
\param type feature type to be transformed
\param height fixed height (used only if column is NULL)
\param field layer number
\param column attribute column used for height
*/
void trans2d(struct Map_info *In, struct Map_info *Out, int type,
double height, const char *field_name, const char *column)
{
int i, ltype, line, field;
int cat;
int ret, ctype;
struct line_pnts *Points;
struct line_cats *Cats;
dbCatValArray cvarr;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_CatValArray_init(&cvarr);
field = Vect_get_field_number(In, field_name);
if (column) {
struct field_info *Fi;
dbDriver *driver;
if (field == -1) {
G_warning(_("Invalid layer number %d, assuming 1"), field);
field = 1;
}
Fi = Vect_get_field(In, field);
if (!Fi) {
G_fatal_error(_("Database connection not defined for layer <%s>"),
field_name);
}
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (!driver) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
}
db_set_error_handler_driver(driver);
/* column type must numeric */
ctype = db_column_Ctype(driver, Fi->table, column);
if (ctype == -1) {
G_fatal_error(_("Column <%s> not found in table <%s>"),
column, Fi->table);
}
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE) {
G_fatal_error(_("Column must be numeric"));
}
G_message(_("Fetching height from <%s> column..."), column);
db_select_CatValArray(driver, Fi->table, Fi->key,
column, NULL, &cvarr);
G_debug(3, "%d records selected", cvarr.n_values);
db_close_database_shutdown_driver(driver);
}
G_message(_("Transforming features..."));
line = 1;
while (1) {
ltype = Vect_read_next_line(In, Points, Cats);
if (ltype == -1) {
G_fatal_error(_("Unable to read vector map"));
}
if (ltype == -2) { /* EOF */
break;
}
G_progress(line, 1000);
if (!(ltype & type))
continue;
if (field != -1 && !Vect_cat_get(Cats, field, &cat))
continue;
if (column) {
Vect_cat_get(Cats, field, &cat);
if (cat < 0) {
G_warning(_("Skipping feature without category"));
continue;
}
if (ctype == DB_C_TYPE_DOUBLE)
ret = db_CatValArray_get_value_double(&cvarr, cat, &height);
else { /* integer */
int height_i;
ret = db_CatValArray_get_value_int(&cvarr, cat, &height_i);
height = (double)height_i;
}
if (ret != DB_OK)
G_warning(_("Unable to get height for feature category %d"),
cat);
}
for (i = 0; i < Points->n_points; i++) {
Points->z[i] = height;
}
Vect_write_line(Out, ltype, Points, Cats);
line++;
}
G_progress(1, 1);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
}
int display_attr(struct Map_info *Map, int type, char *attrcol,
struct cat_list *Clist, LATTR *lattr, int chcat)
{
int i, ltype, more;
struct line_pnts *Points;
struct line_cats *Cats;
int cat;
char buf[2000];
struct field_info *fi;
dbDriver *driver;
dbString stmt, valstr, text;
dbCursor cursor;
dbTable *table;
dbColumn *column;
G_debug(2, "attr()");
if (attrcol == NULL || *attrcol == '\0') {
G_fatal_error(_("attrcol not specified, cannot display attributes"));
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&stmt);
db_init_string(&valstr);
db_init_string(&text);
fi = Vect_get_field(Map, lattr->field);
if (fi == NULL)
return 1;
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);
Vect_rewind(Map);
while (1) {
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 */
D_RGB_color(lattr->color.R, lattr->color.G, lattr->color.B);
D_text_size(lattr->size, lattr->size);
if (lattr->font)
D_font(lattr->font);
if (lattr->enc)
D_encoding(lattr->enc);
if (chcat) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field &&
Vect_cat_in_cat_list(Cats->cat[i], Clist)) {
found = 1;
break;
}
}
if (!found)
continue;
}
else if (Clist->field > 0) {
int found = 0;
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == Clist->field) {
found = 1;
break;
}
}
/* lines with no category will be displayed */
if (Cats->n_cats > 0 && !found)
continue;
}
if (Vect_cat_get(Cats, lattr->field, &cat)) {
int ncats = 0;
/* Read attribute from db */
db_free_string(&text);
for (i = 0; i < Cats->n_cats; i++) {
int nrows;
if (Cats->field[i] != lattr->field)
continue;
db_init_string(&stmt);
sprintf(buf, "select %s from %s where %s = %d", attrcol,
fi->table, fi->key, Cats->cat[i]);
G_debug(2, "SQL: %s", buf);
db_append_string(&stmt, buf);
if (db_open_select_cursor
(driver, &stmt, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open select cursor: '%s'"),
db_get_string(&stmt));
nrows = db_get_num_rows(&cursor);
if (ncats > 0)
db_append_string(&text, "/");
if (nrows > 0) {
table = db_get_cursor_table(&cursor);
column = db_get_table_column(table, 0); /* first column */
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK)
continue;
db_convert_column_value_to_string(column, &valstr);
db_append_string(&text, db_get_string(&valstr));
}
else {
G_warning(_("No attribute found for cat %d: %s"), cat,
db_get_string(&stmt));
}
db_close_cursor(&cursor);
ncats++;
}
show_label_line(Points, ltype, lattr, db_get_string(&text));
}
}
db_close_database_shutdown_driver(driver);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
return 0;
}
struct Point *P_Read_Vector_Region_Map(struct Map_info *Map,
struct Cell_head *Elaboration,
int *num_points, int dim_vect,
int layer)
{
int line_num, pippo, npoints, cat, type;
double x, y, z;
struct Point *obs;
struct line_pnts *points;
struct line_cats *categories;
struct bound_box elaboration_box;
pippo = dim_vect;
obs = (struct Point *)G_calloc(pippo, sizeof(struct Point));
points = Vect_new_line_struct();
categories = Vect_new_cats_struct();
/* Reading points inside elaboration zone */
Vect_region_box(Elaboration, &elaboration_box);
npoints = 0;
line_num = 0;
Vect_rewind(Map);
while ((type = Vect_read_next_line(Map, points, categories)) > 0) {
if (!(type & GV_POINT))
continue;
line_num++;
x = points->x[0];
y = points->y[0];
if (points->z != NULL)
z = points->z[0];
else
z = 0.0;
/* Reading and storing points only if in elaboration_reg */
if (Vect_point_in_box(x, y, z, &elaboration_box)) {
npoints++;
if (npoints >= pippo) {
pippo += dim_vect;
obs =
(struct Point *)G_realloc((void *)obs,
(signed int)pippo *
sizeof(struct Point));
}
/* Storing observation vector */
obs[npoints - 1].coordX = x;
obs[npoints - 1].coordY = y;
obs[npoints - 1].coordZ = z;
obs[npoints - 1].lineID = line_num; /* Storing also the line's number */
Vect_cat_get(categories, layer, &cat);
obs[npoints - 1].cat = cat;
}
}
Vect_destroy_line_struct(points);
Vect_destroy_cats_struct(categories);
*num_points = npoints;
return obs;
}