/*!
\brief Creates buffer around area.
\param Map vector map
\param area area id
\param da distance along major axis
\param db distance along minor axis
\param dalpha angle between 0x and major axis
\param round make corners round
\param caps add caps at line ends
\param tol maximum distance between theoretical arc and output segments
\param[out] oPoints output polygon outer border (ccw order)
\param[out] inner_count number of holes
\param[out] iPoints array of output polygon's holes (cw order)
*/
void Vect_area_buffer2(struct Map_info *Map, int area, double da, double db,
double dalpha, int round, int caps, double tol,
struct line_pnts **oPoints,
struct line_pnts ***iPoints, int *inner_count)
{
struct line_pnts *tPoints, *outer;
struct line_pnts **isles;
int isles_count = 0, n_isles;
int i, isle;
int more = 8;
int isles_allocated = 0;
G_debug(2, "Vect_area_buffer()");
/* initializations */
tPoints = Vect_new_line_struct();
n_isles = Vect_get_area_num_isles(Map, area);
isles_allocated = n_isles;
isles = G_malloc(isles_allocated * sizeof(struct line_pnts *));
/* outer contour */
outer = Vect_new_line_struct();
Vect_get_area_points(Map, area, outer);
/* does not work with zero length line segments */
Vect_line_prune(outer);
/* inner contours */
for (i = 0; i < n_isles; i++) {
isle = Vect_get_area_isle(Map, area, i);
Vect_get_isle_points(Map, isle, tPoints);
/* Check if the isle is big enough */
/*
if (Vect_line_length(tPoints) < 2*PI*max)
continue;
*/
/* does not work with zero length line segments */
Vect_line_prune(tPoints);
add_line_to_array(tPoints, &isles, &isles_count, &isles_allocated,
more);
tPoints = Vect_new_line_struct();
}
buffer_lines(outer, isles, isles_count, 0, da, db, dalpha, round, caps,
tol, oPoints, iPoints, inner_count);
Vect_destroy_line_struct(tPoints);
Vect_destroy_line_struct(outer);
destroy_lines_array(isles, isles_count);
return;
}
/**
* \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 Creates buffer around line.
See also Vect_line_buffer().
\param InPoints input line geometry
\param da distance along major axis
\param db distance along minor axis
\param dalpha angle between 0x and major axis
\param round make corners round
\param caps add caps at line ends
\param tol maximum distance between theoretical arc and output segments
\param[out] oPoints output polygon outer border (ccw order)
\param[out] inner_count number of holes
\param[out] iPoints array of output polygon's holes (cw order)
*/
void Vect_line_buffer2(struct line_pnts *Points, double da, double db,
double dalpha, int round, int caps, double tol,
struct line_pnts **oPoints,
struct line_pnts ***iPoints, int *inner_count)
{
struct planar_graph *pg;
struct line_pnts *tPoints, *outer;
struct line_pnts **isles;
int isles_count = 0;
int res, winding;
int more = 8;
int isles_allocated = 0;
G_debug(2, "Vect_line_buffer()");
Vect_line_prune(Points);
if (Points->n_points == 1)
return Vect_point_buffer2(Points->x[0], Points->y[0], da, db,
dalpha, round, tol, oPoints);
/* initializations */
tPoints = Vect_new_line_struct();
isles = NULL;
pg = pg_create(Points);
/* outer contour */
outer = Vect_new_line_struct();
extract_outer_contour(pg, 0, outer);
/* inner contours */
res = extract_inner_contour(pg, &winding, tPoints);
while (res != 0) {
add_line_to_array(tPoints, &isles, &isles_count, &isles_allocated,
more);
tPoints = Vect_new_line_struct();
res = extract_inner_contour(pg, &winding, tPoints);
}
buffer_lines(outer, isles, isles_count, RIGHT_SIDE, da, db, dalpha, round,
caps, tol, oPoints, iPoints, inner_count);
Vect_destroy_line_struct(tPoints);
Vect_destroy_line_struct(outer);
destroy_lines_array(isles, isles_count);
pg_destroy_struct(pg);
return;
}
/* Writes a site to file open on fptr. */
int G_site_put(struct Map_info *Map, const Site * s)
{
static struct line_pnts *Points = NULL;
static struct line_cats *Cats = NULL;
if (Points == NULL)
Points = Vect_new_line_struct();
if (Cats == NULL)
Cats = Vect_new_cats_struct();
Vect_reset_line(Points);
Vect_reset_cats(Cats);
/* no 3D support so far: s->dim[0] */
Vect_append_point(Points, s->east, s->north, 0.0);
G_debug(4, "cattype = %d", s->cattype);
if (s->cattype == FCELL_TYPE || s->cattype == DCELL_TYPE)
G_fatal_error(_("Category must be integer"));
if (s->cattype == CELL_TYPE)
Vect_cat_set(Cats, 1, s->ccat);
Vect_write_line(Map, GV_POINT, Points, Cats);
return 0;
}
QgsGrassFeatureIterator::QgsGrassFeatureIterator( QgsGrassProvider* p, const QgsFeatureRequest& request )
: QgsAbstractFeatureIterator( request ), P( p )
{
// make sure that only one iterator is active
if ( P->mActiveIterator )
{
QgsMessageLog::logMessage( QObject::tr( "Already active iterator on this provider was closed." ), QObject::tr( "GRASS" ) );
P->mActiveIterator->close();
}
P->mActiveIterator = this;
// check if outdated and update if necessary
P->ensureUpdated();
// Init structures
mPoints = Vect_new_line_struct();
mCats = Vect_new_cats_struct();
mList = Vect_new_list();
// Create selection array
allocateSelection( P->mMap );
resetSelection( 1 );
if ( request.filterType() == QgsFeatureRequest::FilterRect )
{
setSelectionRect( request.filterRect(), request.flags() & QgsFeatureRequest::ExactIntersect );
}
else
{
// TODO: implement fast lookup by feature id
//no filter - use all features
resetSelection( 1 );
}
}
/* create paths for area and islands */
static int plot_area(struct Map_info *P_map, int area, double shift)
{
struct line_pnts *Points;
int j, ret, ni, island;
/* allocate memory for coordinates */
Points = Vect_new_line_struct();
/* plot areas */
if (0 > (ret = Vect_get_area_points(P_map, area, Points))) {
if (ret == -1)
G_warning(_("Read error in vector map"));
return 0;
}
construct_path(Points, shift, WHOLE_PATH);
/* plot islands */
ni = Vect_get_area_num_isles(P_map, area);
for (j = 0; j < ni; j++) {
island = Vect_get_area_isle(P_map, area, j);
if (0 > (ret = Vect_get_isle_points(P_map, island, Points))) {
if (ret == -1)
G_warning(_("Read error in vector map"));
return -1;
}
construct_path(Points, shift, WHOLE_PATH);
}
return 1;
}
double Vect_get_area_perimeter(const struct Map_info *Map, int area)
{
const struct Plus_head *Plus;
struct P_area *Area;
struct line_pnts *Points;
double d;
int i;
G_debug(3, "Vect_get_area_perimeter(): area = %d", area);
Points = Vect_new_line_struct();
Plus = &(Map->plus);
Area = Plus->Area[area];
Vect_get_area_points(Map, area, Points);
Vect_line_prune(Points);
d = Vect_line_geodesic_length(Points);
/* adding island perimeters */
for (i = 0; i < Area->n_isles; i++) {
Vect_get_isle_points(Map, Area->isles[i], Points);
Vect_line_prune(Points);
d += Vect_line_geodesic_length(Points);
}
Vect_destroy_line_struct(Points);
G_debug(3, " perimeter = %f", d);
return (d);
}
/*!
\brief Returns area of area without areas of isles
\param Map vector map
\param area area id
\return area of area without areas of isles
*/
double Vect_get_area_area(const struct Map_info *Map, int area)
{
const struct Plus_head *Plus;
struct P_area *Area;
struct line_pnts *Points;
double size;
int i;
static int first_time = 1;
G_debug(3, "Vect_get_area_area(): area = %d", area);
if (first_time == 1) {
G_begin_polygon_area_calculations();
first_time = 0;
}
Points = Vect_new_line_struct();
Plus = &(Map->plus);
Area = Plus->Area[area];
Vect_get_area_points(Map, area, Points);
size = G_area_of_polygon(Points->x, Points->y, Points->n_points);
/* substructing island areas */
for (i = 0; i < Area->n_isles; i++) {
Vect_get_isle_points(Map, Area->isles[i], Points);
size -= G_area_of_polygon(Points->x, Points->y, Points->n_points);
}
Vect_destroy_line_struct(Points);
G_debug(3, " area = %f", size);
return (size);
}
/*!
\brief Get area boundary points (native format)
Used by Vect_build_line_area() and Vect_get_area_points().
\param Map pointer to Map_info struct
\param lines array of boundary lines
\param n_lines number of lines in array
\param[out] APoints pointer to output line_pnts struct
\return number of points
\return -1 on error
*/
int Vect__get_area_points_nat(const struct Map_info *Map, const plus_t *lines, int n_lines,
struct line_pnts *BPoints)
{
int i, line, aline, dir;
static struct line_pnts *Points;
if (!Points)
Points = Vect_new_line_struct();
Vect_reset_line(BPoints);
for (i = 0; i < n_lines; i++) {
line = lines[i];
aline = abs(line);
G_debug(5, " append line(%d) = %d", i, line);
if (0 > Vect_read_line(Map, Points, NULL, aline))
return -1;
dir = line > 0 ? GV_FORWARD : GV_BACKWARD;
Vect_append_points(BPoints, Points, dir);
BPoints->n_points--; /* skip last point, avoids duplicates */
}
BPoints->n_points++; /* close polygon */
return BPoints->n_points;
}
/** 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 Calculates z coordinate for point from TIN
\param Map pointer to vector map
\param tx,ty point coordinates
\param[out] tz z-coordinate of point
\param[out] angle angle
\param[out] slope slope
\return 1 on success,
\return 0 point is not in area,
\return -1 area has not 4 points or has island
*/
int
Vect_tin_get_z(struct Map_info *Map,
double tx, double ty, double *tz, double *angle, double *slope)
{
int i, area, n_points;
struct Plus_head *Plus;
P_AREA *Area;
static struct line_pnts *Points;
static int first_time = 1;
double *x, *y, *z;
double vx1, vx2, vy1, vy2, vz1, vz2;
double a, b, c, d;
/* TODO angle, slope */
Plus = &(Map->plus);
if (first_time == 1) {
Points = Vect_new_line_struct();
first_time = 0;
}
area = Vect_find_area(Map, tx, ty);
G_debug(3, "TIN: area = %d", area);
if (area == 0)
return 0;
Area = Plus->Area[area];
if (Area->n_isles > 0)
return -1;
Vect_get_area_points(Map, area, Points);
n_points = Points->n_points;
if (n_points != 4)
return -1;
x = Points->x;
y = Points->y;
z = Points->z;
for (i = 0; i < 3; i++) {
G_debug(3, "TIN: %d %f %f %f", i, x[i], y[i], z[i]);
}
vx1 = x[1] - x[0];
vy1 = y[1] - y[0];
vz1 = z[1] - z[0];
vx2 = x[2] - x[0];
vy2 = y[2] - y[0];
vz2 = z[2] - z[0];
a = vy1 * vz2 - vy2 * vz1;
b = vz1 * vx2 - vz2 * vx1;
c = vx1 * vy2 - vx2 * vy1;
d = -a * x[0] - b * y[0] - c * z[0];
/* OK ? */
*tz = -(d + a * tx + b * ty) / c;
G_debug(3, "TIN: z = %f", *tz);
return 1;
}
QgsGrassFeatureIterator::QgsGrassFeatureIterator( QgsGrassFeatureSource* source, bool ownSource, const QgsFeatureRequest& request )
: QgsAbstractFeatureIteratorFromSource<QgsGrassFeatureSource>( source, ownSource, request )
{
sMutex.lock();
// Init structures
mPoints = Vect_new_line_struct();
mCats = Vect_new_cats_struct();
mList = Vect_new_list();
// Create selection array
allocateSelection( mSource->mMap );
resetSelection( 1 );
if ( request.filterType() == QgsFeatureRequest::FilterRect )
{
setSelectionRect( request.filterRect(), request.flags() & QgsFeatureRequest::ExactIntersect );
}
else
{
// TODO: implement fast lookup by feature id
//no filter - use all features
resetSelection( 1 );
}
}
double P_estimate_splinestep(struct Map_info *Map, double *dens, double *dist)
{
int type, npoints = 0;
double xmin = 0, xmax = 0, ymin = 0, ymax = 0;
double x, y, z;
struct line_pnts *points;
struct line_cats *categories;
struct bound_box region_box;
struct Cell_head orig;
G_get_set_window(&orig);
Vect_region_box(&orig, ®ion_box);
points = Vect_new_line_struct();
categories = Vect_new_cats_struct();
Vect_rewind(Map);
while ((type = Vect_read_next_line(Map, points, categories)) > 0) {
if (!(type & GV_POINT))
continue;
x = points->x[0];
y = points->y[0];
if (points->z != NULL)
z = points->z[0];
else
z = 0.0;
/* only use points in current region */
if (Vect_point_in_box(x, y, z, ®ion_box)) {
npoints++;
if (npoints > 1) {
if (xmin > x)
xmin = x;
else if (xmax < x)
xmax = x;
if (ymin > y)
ymin = y;
else if (ymax < y)
ymax = y;
}
else {
xmin = xmax = x;
ymin = ymax = y;
}
}
}
if (npoints > 0) {
/* estimated average distance between points in map units */
*dist = sqrt(((xmax - xmin) * (ymax - ymin)) / npoints);
/* estimated point density as number of points per square map unit */
*dens = npoints / ((xmax - xmin) * (ymax - ymin));
return 0;
}
else {
return -1;
}
}
/*-
* Reads ptr and returns 0 on success,
* -1 on EOF,
* -2 on other fatal error or insufficient data,
* 1 on format mismatch (extra data)
*/
int G_site_get(struct Map_info *Map, Site * s)
{
int i, type, cat;
static struct line_pnts *Points = NULL;
static struct line_cats *Cats = NULL;
SITE_ATT *sa;
if (Points == NULL)
Points = Vect_new_line_struct();
if (Cats == NULL)
Cats = Vect_new_cats_struct();
while (1) {
type = Vect_read_next_line(Map, Points, Cats);
if (type == -1)
return -2; /* Error */
if (type == -2)
return -1; /* EOF */
if (type != GV_POINT)
continue; /* Is not point */
Vect_cat_get(Cats, 1, &cat);
G_debug(4, "Site: %f|%f|%f|#%d", Points->x[0], Points->y[0],
Points->z[0], cat);
s->east = Points->x[0];
s->north = Points->y[0];
if (Vect_is_3d(Map))
s->dim[0] = Points->z[0];
s->ccat = cat;
/* find att */
if (Map->n_site_att > 0) {
sa = (SITE_ATT *) bsearch((void *)&cat, (void *)Map->site_att,
Map->n_site_att, sizeof(SITE_ATT),
site_att_cmp);
if (sa == NULL) {
G_warning(_("Attributes for category %d not found"), cat);
for (i = 0; i < Map->n_site_dbl; i++)
s->dbl_att[i] = 0;
for (i = 0; i < Map->n_site_str; i++)
G_strncpy(s->str_att[i], "", MAX_SITE_STRING);
}
else {
for (i = 0; i < Map->n_site_dbl; i++)
s->dbl_att[i] = sa->dbl[i];
for (i = 0; i < Map->n_site_str; i++)
G_strncpy(s->str_att[i], sa->str[i], MAX_SITE_STRING);
}
}
return 0;
}
}
int
pie(double cx, double cy, int size, double *val, int ncols, COLOR * ocolor,
COLOR * colors)
{
int i, j, n;
double a, end_ang, ang, tot_sum, sum, step, r;
double x, y;
struct line_pnts *Points;
G_debug(4, "pie(): cx = %f cy = %f", cx, cy);
Points = Vect_new_line_struct();
/* Calc sum */
tot_sum = 0;
for (i = 0; i < ncols; i++)
tot_sum += val[i];
step = PI / 180;
r = (D_d_to_u_col(2) - D_d_to_u_col(1)) * size / 2; /* do it better */
/* Draw polygon for each value */
sum = 0;
ang = 0;
for (i = 0; i < ncols; i++) {
sum += val[i];
end_ang = 2 * PI * sum / tot_sum;
Vect_reset_line(Points);
if (val[0] != tot_sum) /* all in one slice, don't draw line to center */
Vect_append_point(Points, cx, cy, 0);
n = (int)ceil((end_ang - ang) / step);
for (j = 0, a = ang; j <= n; j++, a += step) {
if (a > end_ang)
a = end_ang;
x = cx + r * cos(a);
y = cy + r * sin(a);
Vect_append_point(Points, x, y, 0);
}
ang = end_ang;
if (val[0] != tot_sum)
Vect_append_point(Points, cx, cy, 0);
if (!colors[i].none) {
D_RGB_color(colors[i].r, colors[i].g, colors[i].b);
D_polygon_abs(Points->x, Points->y, Points->n_points);
}
D_RGB_color(ocolor->r, ocolor->g, ocolor->b);
D_polyline_abs(Points->x, Points->y, Points->n_points);
}
Vect_destroy_line_struct(Points);
return 0;
}
/*!
\brief Draw area
*/
void draw_area(struct Map_info *Map, int area, struct robject_list *list)
{
int i, centroid, isle;
int num_isles;
struct line_pnts *ipoints;
struct robject *robj;
if (!state.Points)
state.Points = Vect_new_line_struct();
if (!Vect_area_alive(Map, area))
return;
/* check for other centroids -- only area with one centroid is valid */
centroid = Vect_get_area_centroid(Map, area);
if (centroid <= 0)
return;
ipoints = Vect_new_line_struct();
/* get area's boundary */
Vect_get_area_points(Map, area, state.Points);
robj = robj_alloc(TYPE_AREA, state.Points->n_points);
robj_points(robj, state.Points);
list_append(list, robj);
/* check for isles */
num_isles = Vect_get_area_num_isles(Map, area);
for (i = 0; i < num_isles; i++) {
isle = Vect_get_area_isle(Map, area, i);
if (!Vect_isle_alive(Map, isle))
continue;
Vect_get_isle_points(Map, isle, ipoints);
robj = robj_alloc(TYPE_ISLE, ipoints->n_points);
robj_points(robj, ipoints);
list_append(list, robj);
}
Vect_destroy_line_struct(ipoints);
}
/*!
\brief Finds node
Find the node corresponding to each point in the point_list
\param In pointer to Map_info structure
\param point_list list of points (their ids)
*/
void NetA_points_to_nodes(struct Map_info *In, struct ilist *point_list)
{
int i, node;
struct line_pnts *Points = Vect_new_line_struct();
for (i = 0; i < point_list->n_values; i++) {
/* Vect_get_line_nodes(In, point_list->value[i], &node, NULL); */
node = Vect_find_node(In, Points->x[0], Points->y[0], Points->z[0], 0, 0);
point_list->value[i] = node;
}
Vect_destroy_line_struct(Points);
}
int loadSiteCoordinates(struct Map_info *Map, struct Point **points, int region,
struct Cell_head *window, int field, struct cat_list *cat_list)
{
int i, pointIdx;
struct line_pnts *sites;
struct line_cats *cats;
struct bound_box box;
int type;
sites = Vect_new_line_struct();
cats = Vect_new_cats_struct();
*points = NULL;
pointIdx = 0;
/* copy window to box */
Vect_region_box(window, &box);
while ((type = Vect_read_next_line(Map, sites, cats)) > -1) {
if (type != GV_POINT && !(type & GV_LINES))
continue;
if (field > 0 && !Vect_cats_in_constraint(cats, field, cat_list))
continue;
for (i = 0; i < sites->n_points; i++) {
G_debug(4, "Point: %f|%f|%f", sites->x[i], sites->y[i],
sites->z[i]);
if (region && !Vect_point_in_box(sites->x[i], sites->y[i], sites->z[i], &box))
continue;
G_debug(4, "Point in the box");
if ((pointIdx % ALLOC_CHUNK) == 0)
*points = (struct Point *) G_realloc(*points,
(pointIdx + ALLOC_CHUNK) * sizeof(struct Point));
(*points)[pointIdx].x = sites->x[i];
(*points)[pointIdx].y = sites->y[i];
(*points)[pointIdx].z = sites->z[i];
pointIdx++;
}
}
if (pointIdx > 0)
*points = (struct Point *)G_realloc(*points,
(pointIdx + 1) * sizeof(struct Point));
return pointIdx;
}
/*!
\brief Writes point
Writes GV_POINT to Out at the position of the node in <em>In</em>.
\param In pointer to Map_info structure (input vector map)
\param[in,out] Out pointer to Map_info structure (output vector map)
\param node node id
\param Cats pointer to line_cats structures
*/
void NetA_add_point_on_node(struct Map_info *In, struct Map_info *Out,
int node, struct line_cats *Cats)
{
static struct line_pnts *Points;
double x, y, z;
Points = Vect_new_line_struct();
Vect_get_node_coor(In, node, &x, &y, &z);
Vect_reset_line(Points);
Vect_append_point(Points, x, y, z);
Vect_write_line(Out, GV_POINT, Points, Cats);
Vect_destroy_line_struct(Points);
}
/**
\brief Select features by coordinates
\param[in] Map vector map
\param[in] type feature type
\param[in] coords coordinates GRASS parameters
\param[in] thresh threshold value for searching
\param[in,out] List list of selected features
\return number of selected lines
*/
int sel_by_coordinates(struct Map_info *Map,
int type, struct line_pnts *coords, double thresh,
struct ilist *List)
{
int i;
double east, north, maxdist;
struct ilist *List_tmp, *List_in_box;
struct line_pnts *box;
if (first_selection) {
List_tmp = List;
first_selection = 0;
}
else {
List_tmp = Vect_new_list();
}
box = Vect_new_line_struct();
List_in_box = Vect_new_list();
if (thresh < 0)
maxdist = max_distance(thresh);
else
maxdist = thresh;
for (i = 0; i < coords->n_points; i++) {
east = coords->x[i];
north = coords->y[i];
coord2bbox(east, north, maxdist, box);
Vect_select_lines_by_polygon(Map, box, 0, NULL, type, List_in_box);
if (List_in_box->n_values > 0)
Vect_list_append_list(List_tmp, List_in_box);
}
G_debug(1, " %d lines selected (by coordinates)", List_tmp->n_values);
/* merge lists (only duplicate items) */
if (List_tmp != List) {
merge_lists(List, List_tmp);
Vect_destroy_list(List_tmp);
}
Vect_destroy_line_struct(box);
Vect_destroy_list(List_in_box);
return List->n_values;
}
/*!
\brief Returns polygon array of points (outer ring) of given area
\param Map pointer to Map_info structure
\param area area id
\param[out] BPoints points array
\return number of points
\return -1 on error
*/
int Vect_get_area_points(const struct Map_info *Map,
int area, struct line_pnts *BPoints)
{
int i, line, aline, dir;
const struct Plus_head *Plus;
struct P_area *Area;
static int first_time = 1;
static struct line_pnts *Points;
G_debug(3, "Vect_get_area_points(): area = %d", area);
BPoints->n_points = 0;
Plus = &(Map->plus);
Area = Plus->Area[area];
if (Area == NULL) { /* dead area */
G_warning(_("Attempt to read points of nonexistent area"));
return -1; /* error , because we should not read dead areas */
}
if (first_time == 1) {
Points = Vect_new_line_struct();
first_time = 0;
}
G_debug(3, " n_lines = %d", Area->n_lines);
for (i = 0; i < Area->n_lines; i++) {
line = Area->lines[i];
aline = abs(line);
G_debug(3, " append line(%d) = %d", i, line);
if (0 > Vect_read_line(Map, Points, NULL, aline)) {
G_fatal_error(_("Unable to read read line %d"), aline);
}
G_debug(3, " line n_points = %d", Points->n_points);
if (line > 0)
dir = GV_FORWARD;
else
dir = GV_BACKWARD;
Vect_append_points(BPoints, Points, dir);
if (i != (Area->n_lines - 1)) /* all but not last */
BPoints->n_points--;
G_debug(3, " area n_points = %d", BPoints->n_points);
}
return BPoints->n_points;
}
/*!
\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;
}
int point_in_buffer(struct buf_contours *arr_bc, struct spatial_index *si,
struct Map_info *Buf, double x, double y)
{
int i, j, ret, flag;
struct bound_box bbox;
static struct ilist *List = NULL;
static struct line_pnts *Points = NULL;
if (List == NULL)
List = Vect_new_list();
if (Points == NULL)
Points = Vect_new_line_struct();
/* select outer contours overlapping with centroid (x, y) */
bbox.W = bbox.E = x;
bbox.N = bbox.S = y;
bbox.T = PORT_DOUBLE_MAX;
bbox.B = -PORT_DOUBLE_MAX;
Vect_spatial_index_select(si, &bbox, List);
for (i = 0; i < List->n_values; i++) {
Vect_read_line(Buf, Points, NULL, arr_bc[List->value[i]].outer);
ret = Vect_point_in_poly(x, y, Points);
if (ret == 0)
continue;
flag = 1;
for (j = 0; j < arr_bc[List->value[i]].inner_count; j++) {
if (arr_bc[List->value[i]].inner[j] < 1)
continue;
Vect_read_line(Buf, Points, NULL, arr_bc[List->value[i]].inner[j]);
ret = Vect_point_in_poly(x, y, Points);
if (ret != 0) { /* inside inner contour */
flag = 0;
break;
}
}
if (flag) {
/* (x,y) is inside outer contour and outside inner contours of arr_bc[i] */
return 1;
}
}
return 0;
}
/*!
\brief Returns polygon array of points for given isle
\param Map vector map
\param isle island id
\param[out] BPoints points array
\return number of points
\return -1 on error
*/
int
Vect_get_isle_points(const struct Map_info *Map,
int isle, struct line_pnts *BPoints)
{
int i, line, aline, dir;
const struct Plus_head *Plus;
struct P_isle *Isle;
static int first_time = 1;
static struct line_pnts *Points;
G_debug(3, "Vect_get_isle_points(): isle = %d", isle);
BPoints->n_points = 0;
Plus = &(Map->plus);
Isle = Plus->Isle[isle];
if (first_time == 1) {
Points = Vect_new_line_struct();
first_time = 0;
}
G_debug(3, " n_lines = %d", Isle->n_lines);
for (i = 0; i < Isle->n_lines; i++) {
line = Isle->lines[i];
aline = abs(line);
G_debug(3, " append line(%d) = %d", i, line);
if (0 > Vect_read_line(Map, Points, NULL, aline)) {
G_fatal_error(_("Unable to read line %d"), aline);
}
G_debug(3, " line n_points = %d", Points->n_points);
if (line > 0)
dir = GV_FORWARD;
else
dir = GV_BACKWARD;
Vect_append_points(BPoints, Points, dir);
if (i != (Isle->n_lines - 1)) /* all but not last */
BPoints->n_points--;
G_debug(3, " isle n_points = %d", BPoints->n_points);
}
return (BPoints->n_points);
}
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;
}
int print_tree(struct multtree *tree,
double x_orig, double y_orig, struct Map_info *Map)
{
double xarray[5], yarray[5], zarray[5];
struct line_pnts *Points;
struct line_cats *Cats;
int j;
int type = GV_LINE;
if (tree == NULL)
return 0;
if (tree->data == NULL)
return 0;
if (tree->leafs != NULL) {
for (j = 0; j < 4; j++) {
print_tree(tree->leafs[j], x_orig, y_orig, Map);
}
}
else {
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
xarray[0] = ((struct quaddata *)(tree->data))->x_orig + x_orig;
yarray[0] = ((struct quaddata *)(tree->data))->y_orig + y_orig;
xarray[1] = xarray[0];
yarray[3] = yarray[0];
xarray[3] = ((struct quaddata *)(tree->data))->xmax + x_orig;
yarray[1] = ((struct quaddata *)(tree->data))->ymax + y_orig;
yarray[2] = yarray[1];
xarray[2] = xarray[3];
yarray[4] = yarray[0];
xarray[4] = xarray[0];
if (Vect_copy_xyz_to_pnts(Points, xarray, yarray, zarray, 5) < 0) {
clean();
G_fatal_error(_("Out of memory"));
}
Vect_write_line(Map, (unsigned int)type, Points, Cats);
G_free(Points);
}
return 1;
}
int move_line_begin(void *closure)
{
struct move_line *ml = closure;
G_debug(2, "move_line()");
ml->Points = Vect_new_line_struct();
ml->Cats = Vect_new_cats_struct();
i_prompt(_("Move point, line, boundary, or centroid:"));
i_prompt_buttons(_("Select"), "", _("Quit tool"));
ml->thresh = get_thresh();
G_debug(2, "thresh = %f", ml->thresh);
ml->last_line = 0;
set_mode(MOUSE_POINT);
return 0;
}
/* writes binary and ASCII digit files and supplemental file */
static int write_bnd(struct COOR *line_begin, struct COOR *line_end, /* start and end point of line */
int n /* number of points to write */
)
{
static struct line_pnts *points = NULL;
double x;
double y;
struct COOR *p, *last;
int i;
if (!points)
points = Vect_new_line_struct();
Vect_reset_line(points);
p = line_begin;
y = cell_head.north - (double)p->row * cell_head.ns_res;
x = cell_head.west + (double)p->col * cell_head.ew_res;
Vect_append_point(points, x, y, 0.0);
for (i = 0; i < n; i++) {
last = p;
/* this should NEVER happen */
if ((p = move(p)) == NULPTR)
G_fatal_error(_("write_bnd: line terminated unexpectedly\n"
"previous (%d) point %p (%d,%d,%d) %p %p"),
direction, last, last->row, last->col, last->node,
last->fptr, last->bptr);
y = cell_head.north - p->row * cell_head.ns_res;
x = cell_head.west + p->col * cell_head.ew_res;
Vect_append_point(points, x, y, 0.0);
}
Vect_write_line(&Map, GV_BOUNDARY, points, Cats);
return 0;
}
/*
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);
}
