break_polygons.c

Go to the documentation of this file.

/*!
   \file lib/vector/Vlib/break_polygons.c
 
   \brief Vector library - clean geometry (break polygons)
 
   Higher level functions for reading/writing/manipulating vectors.
 
   SPDX-FileCopyrightText: 2001-2009 GRASS Development Team
   SPDX-License-Identifier: GPL-2.0-or-later
 
   \author Radim Blazek
   \author Update for GRASS 7 Markus Metz
 */
 
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <math.h>
#include <errno.h>
#include <string.h>
#include <grass/vector.h>
#include <grass/glocale.h>
 
/* TODO: 3D support
 *
 * atan2() gives angle from x-axis
 * this is unambiguous only in 2D, not in 3D
 *
 * one possibility would be to store unit vectors of length 1
 * in struct XPNT
 * double a1[3], a2[3];
 *
 * length = sqrt(dx * dx + dy * dy + dz * dz);
 * dx /= length; dy /= length; dz /=length;
 * a1[0] = dx; a1[1] = dy; a1[2] = dz;
 *
 * get second dx, dy, dz
 * length = sqrt(dx * dx + dy * dy + dz * dz);
 * dx /= length; dy /= length; dz /=length;
 * a2[0] = dx; a2[1] = dy; a2[2] = dz;
 *
 * equal angles
 * if (a1[0] == a2[0] && a1[1] == a2[1] && a1[2] == a2[2])
 *
 * disadvantage: increased memory consumption
 *
 * new function Vect_break_faces() ?
 *
 */
 
typedef struct {
    double x, y;   /* coords */
    double a1, a2; /* angles */
    char cross;    /* 0 - do not break, 1 - break */
    char used;     /* 0 - was not used to break line, 1 - was used to break line
                    *   this is stored because points are automatically marked as
                    * cross, even if not used     later to break lines */
} XPNT;
 
typedef struct {
    double a1, a2; /* angles */
    char cross;    /* 0 - do not break, 1 - break */
    char used;     /* 0 - was not used to break line, 1 - was used to break line
                    *   this is stored because points are automatically marked as
                    * cross, even if not used     later to break lines */
} XPNT2;
 
static int fpoint;
 
/* Function called from RTreeSearch for point found */
static int srch(int id, const struct RTree_Rect *rect G_UNUSED,
                void *arg G_UNUSED)
{
    fpoint = id;
 
    return 0; /* stop searching */
}
 
/* function used by binary tree to compare items */
static int compare_xpnts(const void *Xpnta, const void *Xpntb)
{
    XPNT *a, *b;
 
    a = (XPNT *)Xpnta;
    b = (XPNT *)Xpntb;
 
    if (a->x > b->x)
        return 1;
    else if (a->x < b->x)
        return -1;
    else {
        if (a->y > b->y)
            return 1;
        else if (a->y < b->y)
            return -1;
        else
            return 0;
    }
 
    G_warning(_("Break polygons: Bug in binary tree!"));
    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;
    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);
    (void)remove(filename);
    G_free(filename);
 
    filename = G_tempfile();
    xpntfd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
    if (xpntfd < 0) {
        close(RTree->fd);
        G_free(filename);
        G_fatal_error(_("Failed to create xpnt temporary file: %s"),
                      strerror(errno));
    }
    (void)remove(filename);
    G_free(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 */
 
    npoints = 1; /* index starts from 1 ! */
    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);
 
            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, 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 */
                if (lseek(xpntfd, (off_t)(fpoint - 1) * sizeof(XPNT2),
                          SEEK_SET) == -1) {
                    int err = errno;
                    G_fatal_error(
                        _("File read/write operation failed: %s (%d)"),
                        strerror(err), err);
                }
                if (read(xpntfd, &XPnt, sizeof(XPNT2)) < 0)
                    G_fatal_error(_("File reading error in %s() %d:%s"),
                                  __func__, errno, strerror(errno));
                if (XPnt.cross == 1)
                    continue; /* already marked */
 
                /* Check angles */
                if (cross) {
                    XPnt.cross = 1;
                    /* write point */
                    if (lseek(xpntfd, (off_t)(fpoint - 1) * sizeof(XPNT2),
                              SEEK_SET) == -1) {
                        int err = errno;
                        G_fatal_error(
                            _("File read/write operation failed: %s (%d)"),
                            strerror(err), err);
                    }
                    if (write(xpntfd, &XPnt, sizeof(XPNT2)) < 0)
                        G_fatal_error(_("File writing error in %s() %d:%s"),
                                      __func__, errno, strerror(errno));
                }
                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;
                        /* write point */
                        if (lseek(xpntfd, (off_t)(fpoint - 1) * sizeof(XPNT2),
                                  SEEK_SET) == -1) {
                            int err = errno;
                            G_fatal_error(
                                _("File read/write operation failed: %s (%d)"),
                                strerror(err), err);
                        }
                        if (write(xpntfd, &XPnt, sizeof(XPNT2)) < 0)
                            G_fatal_error(_("File writing error in %s() %d:%s"),
                                          __func__, errno, strerror(errno));
                    }
                }
            }
            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;
                }
                else {
                    XPnt.a1 = a1;
                    XPnt.a2 = a2;
                    XPnt.cross = 0;
                }
                /* write point */
                if (lseek(xpntfd, (off_t)(npoints - 1) * sizeof(XPNT2),
                          SEEK_SET) == -1) {
                    int err = errno;
                    G_fatal_error(
                        _("File read/write operation failed: %s (%d)"),
                        strerror(err), err);
                }
                if (write(xpntfd, &XPnt, sizeof(XPNT2)) < 0)
                    G_fatal_error(_("File writing error in %s() %d:%s"),
                                  __func__, errno, strerror(errno));
 
                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);
 
            /* 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, srch, NULL);
            G_debug(3, "fpoint =  %d", fpoint);
 
            /* read point */
            if (lseek(xpntfd, (off_t)(fpoint - 1) * sizeof(XPNT2), SEEK_SET) ==
                -1) {
                int err = errno;
                G_fatal_error(_("File read/write operation failed: %s (%d)"),
                              strerror(err), err);
            }
            if (read(xpntfd, &XPnt, sizeof(XPNT2)) < 0)
                G_fatal_error(_("File reading error in %s() %d:%s"), __func__,
                              errno, strerror(errno));
 
            /* 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 */
                        if (lseek(xpntfd, (off_t)(fpoint - 1) * sizeof(XPNT2),
                                  SEEK_SET) == -1) {
                            int err = errno;
                            G_fatal_error(
                                _("File read/write operation failed: %s (%d)"),
                                strerror(err), err);
                        }
                        if (write(xpntfd, &XPnt, sizeof(XPNT2)) < 0)
                            G_fatal_error(_("File writing error in %s() %d:%s"),
                                          __func__, errno, strerror(errno));
                    }
                }
 
                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);
}
 
/* 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;
    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 */
 
    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);
 
            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;
                }
                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;
                    }
                }
            }
            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;
                }
                else {
                    XPnt_search.a1 = a1;
                    XPnt_search.a2 = a2;
                    XPnt_search.cross = 0;
                }
 
                /* Add to tree */
                rbtree_insert(RBTree, &XPnt_search);
            }
        }
    }
 
    nbreaks = 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);
 
            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);
    Vect_destroy_cats_struct(ErrCats);
    G_verbose_message(_("Breaks: %d"), nbreaks);
}
 
/*!
   \brief Break polygons in vector map
 
   Breaks lines specified by type in vector map. Points at
   intersections may be optionally written to error map. Input vector
   map must be opened on level 2 for update at least on GV_BUILD_BASE.
 
   Function is optimized for closed polygons rings (e.g. imported from
   OGR) but with clean geometry - adjacent polygons mostly have
   identical boundary. Function creates database of ALL points in the
   vector map, and then is looking for those where polygons should be
   broken.  Lines may be broken only at points existing in input
   vector map!
 
   \param Map input map where polygons will be broken
   \param type type of line to be broken (GV_LINE or GV_BOUNDARY)
   \param Err vector map where points at intersections will be written or NULL
 */
void Vect_break_polygons(struct Map_info *Map, int type, struct Map_info *Err)
{
    if (getenv("GRASS_VECTOR_LOWMEM"))
        Vect_break_polygons_file(Map, type, Err);
    else
        Vect_break_polygons_mem(Map, type, Err);
}