break.c

Go to the documentation of this file.

/*!
   \file lib/vector/vedit/break.c
 
   \brief Vedit library - split, break, connect lines
 
   (C) 2007-2008 by the GRASS Development Team
 
   This program is free software under the GNU General Public License
   (>=v2).  Read the file COPYING that comes with GRASS for details.
 
   \author Martin Landa <landa.martin gmail.com>
 */
 
#include <math.h>
#include <grass/vedit.h>
 
static int connect_lines(struct Map_info *, int, int, int, double,
                         struct ilist *);
 
/*!
   \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 */
            Vect_reset_line(Points2);
            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 */
            if (j == 0)
                newline = Vect_rewrite_line(Map, line, type, Points2, Cats);
            else
                newline = Vect_write_line(Map, 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 Connect lines in given threshold
 
   \code
   \                 \
   id1   \           ->       \
   \
   id2 ---------           -----+---
   \endcode
 
   If two lines are selected and <i>thresh</i> is -1, no limit is
   applied.
 
   \param Map pointer to Map_info
   \param List list of selected lines
   \param thresh threshold value
 
   \return number of modified lines
   \return -1 on error
 */
int Vedit_connect_lines(struct Map_info *Map, struct ilist *List, double thresh)
{
    int nlines_modified, connected;
    int i, j, node[2], n_nodes;
    int line, found;
    double x, y, z;
 
    struct ilist *List_exclude, *List_found;
 
    nlines_modified = 0;
 
    List_exclude = Vect_new_list();
    List_found = Vect_new_list();
 
    n_nodes = 2;
 
    /* collect lines to be modified */
    for (i = 0; i < List->n_values; i++) {
        line = List->value[i];
 
        if (!Vect_line_alive(Map, line))
            continue;
 
        if (Vect_get_line_type(Map, line) & GV_POINTS)
            continue;
 
        node[0] = node[1] = -1;
        Vect_get_line_nodes(Map, line, &(node[0]), &(node[1]));
        if (node[0] < 0 || node[1] < 0)
            continue;
 
        connected = 0;
        Vect_reset_list(List_exclude);
        Vect_list_append(List_exclude, line);
        for (j = 0; j < n_nodes && !connected; j++) {
            /* for each line node find lines in threshold */
            Vect_get_node_coor(Map, node[j], &x, &y, &z);
 
            do {
                /* find first nearest line */
                found =
                    Vect_find_line_list(Map, x, y, z, GV_LINES, thresh,
                                        WITHOUT_Z, List_exclude, List_found);
 
                if (found > 0 && Vect_line_alive(Map, found)) {
                    /* try to connect lines (given node) */
                    G_debug(3, "Vedit_connect_lines(): lines=%d,%d", line,
                            found);
                    if (connect_lines(Map, !j, line, found, thresh, List)) {
                        G_debug(
                            3,
                            "Vedit_connect_lines(): lines=%d,%d -> connected",
                            line, found);
                        nlines_modified += 2;
                        connected = 1;
                    }
                }
 
                Vect_list_append(List_exclude, found);
            } while (List_found->n_values > 0 && !connected);
        }
    }
 
    Vect_destroy_list(List_exclude);
    Vect_destroy_list(List_found);
 
    return nlines_modified;
}
 
int connect_lines(struct Map_info *Map, int first, int line_from, int line_to,
                  double thresh, struct ilist *List UNUSED)
{
    int line_new;
    int type_from, type_to;
    int n_points, seg, is;
    double x, y, px, py, x1, y1;
    double dist, spdist, lpdist, length, dist_p;
    double angle_t, angle_f, angle;
 
    struct line_pnts *Points_from, *Points_to, *Points_final;
    struct line_cats *Cats_from, *Cats_to;
 
    Points_from = Vect_new_line_struct();
    Points_to = Vect_new_line_struct();
    Points_final = Vect_new_line_struct();
    Cats_from = Vect_new_cats_struct();
    Cats_to = Vect_new_cats_struct();
 
    type_from = Vect_read_line(Map, Points_from, Cats_from, line_from);
    type_to = Vect_read_line(Map, Points_to, Cats_to, line_to);
 
    line_new = 0;
    if (!(type_from & GV_LINES) || !(type_to & GV_LINES))
        line_new = -1;
 
    if (line_new > -1) {
        n_points = Points_from->n_points - 1;
 
        if (first) {
            x = Points_from->x[0];
            y = Points_from->y[0];
        }
        else {
            x = Points_from->x[n_points];
            y = Points_from->y[n_points];
        }
        seg = Vect_line_distance(Points_to, x, y, 0.0, WITHOUT_Z, &px, &py,
                                 NULL, &dist, &spdist, &lpdist);
 
        if (seg > 0 && dist > 0.0 && (thresh < 0. || dist <= thresh)) {
            /* lines in threshold */
            if (first)
                length = 0;
            else
                length = Vect_line_length(Points_from);
 
            if (Vect_point_on_line(Points_from, length, NULL, NULL, NULL,
                                   &angle_f, NULL) > 0) {
                if (Vect_point_on_line(Points_to, lpdist, NULL, NULL, NULL,
                                       &angle_t, NULL) > 0) {
                    angle = angle_t - angle_f;
                    dist_p = fabs(dist / sin(angle));
 
                    if (first) {
                        if (angle_f < 0)
                            angle_f -= M_PI;
                        else
                            angle_f += M_PI;
                    }
 
                    x1 = x + dist_p * cos(angle_f);
                    y1 = y + dist_p * sin(angle_f);
 
                    length = Vect_line_length(Points_to);
                    Vect_line_insert_point(Points_to, seg, x1, y1, 0.);
                    if (fabs(Vect_line_length(Points_to) - length) <
                        length * 1e-3) {
                        /* lines connected -> split line_to */
                        /* update line_from */
                        if (first) {
                            Points_from->x[0] = x1;
                            Points_from->y[0] = y1;
                        }
                        else {
                            Points_from->x[n_points] = x1;
                            Points_from->y[n_points] = y1;
                        }
 
                        line_new = Vect_rewrite_line(Map, line_from, type_from,
                                                     Points_from, Cats_from);
                        /* Vect_list_append(List, line_new); */
 
                        /* update line_to  -- first part */
                        Vect_reset_line(Points_final);
                        for (is = 0; is < seg; is++) {
                            Vect_append_point(Points_final, Points_to->x[is],
                                              Points_to->y[is],
                                              Points_to->z[is]);
                        }
                        Vect_append_point(Points_final, x1, y1, 0.0);
                        line_new = Vect_rewrite_line(Map, line_to, type_to,
                                                     Points_final, Cats_to);
                        /* Vect_list_append(List, line_new); */
 
                        /* write second part */
                        Vect_reset_line(Points_final);
                        Vect_append_point(Points_final, x1, y1, 0.0);
                        for (is = seg; is < Points_to->n_points; is++) {
                            Vect_append_point(Points_final, Points_to->x[is],
                                              Points_to->y[is],
                                              Points_to->z[is]);
                        }
 
                        /* rewrite first part */
                        line_new = Vect_write_line(Map, type_to, Points_final,
                                                   Cats_to);
                        /* Vect_list_append(List, line_new); */
                    }
                }
            }
        }
    }
 
    Vect_destroy_line_struct(Points_from);
    Vect_destroy_line_struct(Points_to);
    Vect_destroy_line_struct(Points_final);
    Vect_destroy_cats_struct(Cats_from);
    Vect_destroy_cats_struct(Cats_to);
 
    return line_new > 0 ? 1 : 0;
}