vector/Vlib/copy.c

Go to the documentation of this file.

/*!
   \file lib/vector/Vlib/copy.c
 
   \brief Vector library - Copy vector features and attribute tables linked to
   the map
 
   Higher level functions for reading/writing/manipulating vectors.
 
   SPDX-FileCopyrightText: 2001-2009, 2012-2013 GRASS Development Team
   SPDX-License-Identifier: GPL-2.0-or-later
 
   \author Original author CERL, probably Dave Gerdes or Mike Higgins.
   \author Update to GRASS 5.7 Radim Blazek and David D. Gray.
   \author Update to GRASS 7 by Martin Landa <landa.martin gmail.com>
   (OGR/PostGIS topology support)
 */
 
#include <grass/vector.h>
#include <grass/glocale.h>
 
#include "local_proto.h"
 
/*!
   \brief Copy topological elements
 
   - simple features (None)
   - native topo (GRASS)
   - PostGIS Topo
 */
#define TOPO_NONE    -1
#define TOPO_NATIVE  1
#define TOPO_POSTGIS 2
 
#ifdef HAVE_POSTGRES
#include "pg_local_proto.h"
#define NOPG_UNUSED
#else
#define NOPG_UNUSED G_UNUSED
#endif
 
static int copy_lines_1(struct Map_info *, int, struct Map_info *);
static int copy_lines_2(struct Map_info *, int, int, struct Map_info *);
 
#if 0
static int copy_nodes(struct Map_info *, struct Map_info *);
#endif
static int copy_line_nodes(struct Map_info *, int, int, struct line_pnts *,
                           struct Map_info *);
static int is_isle(struct Map_info *, int);
 
/*!
   \brief Copy all alive vector features from input vector map to
   output vector map
 
   \param In input vector map
   \param[out] Out output vector map
 
   \return 0 on success
   \return 1 on error
 */
int Vect_copy_map_lines(struct Map_info *In, struct Map_info *Out)
{
    return Vect_copy_map_lines_field(In, -1, Out);
}
 
/*!
   \brief Copy all alive vector features from given layer from input
   vector map to output vector map
 
   Note: Try to copy on level 2 otherwise level 1 is used.
 
   \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 ret, format, topo;
    const char *geometry_type = NULL;
    const char *map_name = NULL;
 
    if (Vect_level(In) < 1)
        G_fatal_error(
            _("Unable to copy features. Input vector map <%s> is not open"),
            Vect_get_full_name(In));
 
    format = Out->format; /* do not use Vect_maptype(), we need native
                             format for temporary maps here */
    topo = TOPO_NONE;
    if (format == GV_FORMAT_NATIVE) {
        topo = TOPO_NATIVE;
    }
    else if (format == GV_FORMAT_POSTGIS && Out->fInfo.pg.toposchema_name) {
        int type;
 
        topo = TOPO_POSTGIS;
 
        /* get type of first feature from input vector map */
        Vect_rewind(In);
        Vect_set_constraint_type(In, GV_POINTS | GV_LINES);
        type = Vect_read_next_line(In, NULL, NULL);
 
        /* create feature table with given feature type */
        if (0 > Vect_write_line(Out, type, NULL, NULL)) {
            G_warning(_("Unable to create PostGIS layer <%s>"),
                      Vect_get_finfo_layer_name(Out));
            return 1;
        }
    }
 
    /* Note: sometimes is important to copy on level 2 (pseudotopo
       centroids) and sometimes on level 1 if build take too long time
     */
    ret = 0;
    if (Vect_level(In) >= 2) {
        /* -> copy features on level 2 */
#if 0
        if (topo == TOPO_POSTGIS) {
            /* PostGIS topology - copy also nodes */
            copy_nodes(In, Out);
        }
#endif
        /* copy features */
        ret += copy_lines_2(In, field, topo, Out);
 
        if (topo == TOPO_NONE) {
            /* check output feature type, centroids can be exported as
             * points; boundaries as linestrings */
            geometry_type = Vect_get_finfo_geometry_type(Out);
            if (geometry_type && strcmp(geometry_type, "polygon") == 0) {
                /* copy areas - external formats and simple features access only
                 */
                ret += Vect__copy_areas(In, field, Out);
            }
            G_free((void *)geometry_type);
        }
    }
    else {
        /* -> copy features on level 1 */
        if (topo == TOPO_NONE) {
            map_name = Vect_get_full_name(In);
            G_warning(_("Vector map <%s> not open on topological level. "
                        "Areas will be skipped!"),
                      map_name);
            G_free((void *)map_name);
        }
 
        ret += copy_lines_1(In, field, Out);
    }
    return ret > 0 ? 1 : 0;
}
 
/*!
   \brief Copy vector features on level 1
 
   \param In input vector map
   \param field layer number (-1 for all layers)
   \param Out output vector map
 
   \return 0 on success
   \return 1 on error
 */
int copy_lines_1(struct Map_info *In, int field, struct Map_info *Out)
{
    int ret, type;
    const char *map_name = NULL;
 
    struct line_pnts *Points;
    struct line_cats *Cats;
 
    Points = Vect_new_line_struct();
    Cats = Vect_new_cats_struct();
 
    ret = 0;
 
    Vect_rewind(In);
    while (TRUE) {
        type = Vect_read_next_line(In, Points, Cats);
        if (type == -1) {
            map_name = Vect_get_full_name(In);
            G_warning(_("Unable to read vector map <%s>"), map_name);
            G_free((void *)map_name);
            ret = 1;
            break;
        }
        else if (type == -2) { /* EOF */
            break;             /* free allocated space and return */
        }
        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_cats_struct(Cats);
 
    return ret;
}
 
/*!
   \brief Copy vector features on level 2
 
   \param In input vector map
   \param field layer number (-1 for all layers)
   \param topo topo access (none, native, postgis)
   \param Out output vector map
 
   \return 0 on success
   \return 1 on error
 */
int copy_lines_2(struct Map_info *In, int field, int topo, struct Map_info *Out)
{
    int i, type, nlines, nskipped;
    int ret, left, rite, centroid, with_z;
 
    struct line_pnts *Points, *CPoints, *NPoints;
    struct line_cats *Cats, *CCats;
 
    const char *ftype = NULL;
    const char *map_name = NULL;
 
    Points = Vect_new_line_struct();
    CPoints = Vect_new_line_struct();
    NPoints = Vect_new_line_struct();
    Cats = Vect_new_cats_struct();
    CCats = Vect_new_cats_struct();
 
    with_z = Vect_is_3d(In);
 
    ret = 0;
    nlines = Vect_get_num_lines(In);
    if (topo == TOPO_NONE) {
        ftype = Vect_get_finfo_geometry_type(Out);
        G_debug(2, "feature type: %s", ftype ? ftype : "?");
        if (!ftype)
            G_message(_("Copying features..."));
        else
            G_message(_("Copying features (%s)..."), ftype);
    }
    else
        G_message(_("Copying features..."));
 
    Vect_append_point(NPoints, 0., 0., 0.);
    nskipped = 0;
    for (i = 1; i <= nlines; i++) {
        if (!Vect_line_alive(In, i))
            continue;
 
        G_percent(i, nlines, 2);
        type = Vect_read_line(In, Points, Cats, i);
        if (type == -1) {
            map_name = Vect_get_full_name(In);
            G_warning(_("Unable to read vector map <%s>"), map_name);
            G_free((void *)map_name);
            ret = 1;
            break; /* free allocated space and return */
        }
        if (type == 0)
            continue; /* dead line */
        if (In->constraint.type_flag) {
            /* skip feature by type */
            if (!(type & In->constraint.type))
                continue;
        }
 
        if (topo == TOPO_NONE) {
            /* OGR/PostGIS layers (simple features) */
            int skip = FALSE;
 
            if (type == GV_BOUNDARY)
                /* boundaries are written as linestrings when output
                 * feature type is defined as 'linestring', otherwise
                 * they are skipped */
                if (ftype && strcmp(ftype, "linestring") != 0)
                    skip = TRUE;
 
            /* centroids are stored in topo polygon defined by areas
               (topo required) */
            if (type == GV_CENTROID) {
                /* centroids are written as points when output feature
                 * type is defined as 'point', otherwise they are
                 * skipped */
                if (ftype && strcmp(ftype, "point") != 0)
                    skip = TRUE;
            }
 
            if (skip)
                continue;
        }
 
        /* 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 = TRUE;
 
                    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 = FALSE;
                        }
                    }
                    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 = FALSE;
                            }
                        }
                    }
                    if (skip_bndry)
                        continue;
                }
            }
            else if (Vect_cat_get(Cats, field, NULL) == 0) {
                nskipped++;
                continue; /* different layer */
            }
        }
 
        /* copy also nodes connected to the line (PostGIS Topology
         * mode only) */
        if (topo == TOPO_POSTGIS && (type & GV_LINES)) {
            int n1, n2;
 
            struct P_line *Line;
            struct Format_info_offset *offset;
 
            offset = &(Out->fInfo.pg.offset);
 
            n1 = n2 = -1;
            Line = In->plus.Line[i];
            if (Line) {
                if (type == GV_LINE) {
                    struct P_topo_l *topo = (struct P_topo_l *)Line->topo;
 
                    n1 = topo->N1;
                    n2 = topo->N2;
                }
                else if (type == GV_BOUNDARY) {
                    struct P_topo_b *topo = (struct P_topo_b *)Line->topo;
 
                    n1 = topo->N1;
                    n2 = topo->N2;
                }
            }
 
            if (n1 > 0 &&
                (n1 > offset->array_num || offset->array[n1 - 1] == 0))
                copy_line_nodes(In, n1, with_z, NPoints, Out);
            if (n2 > 0 &&
                (n2 > offset->array_num || offset->array[n2 - 1] == 0))
                copy_line_nodes(In, n2, with_z, NPoints, Out);
        }
 
        if (-1 == Vect_write_line(Out, type, Points, Cats)) {
            G_warning(_("Writing new feature failed"));
            ret = 1;
            goto free_exit;
        }
    }
 
    if (nskipped > 0)
        G_important_message(
            _("%d features without category or from different layer skipped"),
            nskipped);
free_exit:
    Vect_destroy_line_struct(Points);
    Vect_destroy_line_struct(CPoints);
    Vect_destroy_line_struct(NPoints);
    Vect_destroy_cats_struct(Cats);
    Vect_destroy_cats_struct(CCats);
    G_free((void *)ftype);
 
    return ret;
}
 
#if 0
/*!
   \brief Copy nodes as points (PostGIS Topology only)
 
   \param In input vector map
   \param Out output vector map
 
   \return 0 on success
   \return 1 on error
 */
int copy_nodes(struct Map_info *In, struct Map_info *Out)
{
    int nnodes, node, with_z;
 
    struct line_pnts *Points;
 
    Points = Vect_new_line_struct();
 
    with_z = Vect_is_3d(In);
 
    nnodes = Vect_get_num_nodes(In);
    G_message(_("Exporting nodes..."));
    Vect_append_point(Points, 0., 0., 0.);
    for (node = 1; node <= nnodes; node++) {
        G_debug(3, "Exporting GRASS node %d", node);
 
        G_percent(node, nnodes, 5);
        copy_line_nodes(In, node, with_z, Points, Out);
    }
 
    Vect_destroy_line_struct(Points);
 
    return 0;
}
#endif
 
int copy_line_nodes(struct Map_info *In, int node, int with_z,
                    struct line_pnts *Points, struct Map_info *Out NOPG_UNUSED)
{
    double x, y, z;
 
    Vect_get_node_coor(In, node, &x, &y, &z);
    Points->x[0] = x;
    Points->y[0] = y;
    if (with_z)
        Points->z[0] = z;
 
#ifdef HAVE_POSTGRES
    if (-1 == V2__write_node_pg(Out, Points)) {
        G_warning(_("Writing node %d failed"), node);
        return 1;
    }
#else
    G_fatal_error(_("GRASS is not compiled with PostgreSQL support"));
    return 1;
#endif
 
    return 0;
}
 
/*!
   \brief Check if area is part of an isle
 
   Check for areas that are part of isles which in turn are inside
   another area.
 
   \param Map pointer to Map_info struct
   \param area area id
 
   \return TRUE if area forms an isle otherwise FALSE
 */
int is_isle(struct Map_info *Map, int area)
{
    int i, line, left, right, isle, is_isle;
 
    struct ilist *List;
 
    List = Vect_new_list();
    Vect_get_area_boundaries(Map, area, List);
 
    is_isle = FALSE;
    /* do we need to check all boundaries ? no */
    for (i = 0; i < List->n_values && !is_isle; i++) {
        line = List->value[i];
        if (1 != Vect_get_line_areas(Map, abs(line), &left, &right))
            continue;
 
        isle = line > 0 ? left : right;
 
        if (isle < 0 && Vect_get_isle_area(Map, abs(isle)) > 0) {
            is_isle = TRUE;
            break;
        }
    }
 
    G_debug(3, "is_isle(): area %d skip? -> %s", area, is_isle ? "yes" : "no");
    Vect_destroy_list(List);
 
    return is_isle;
}
 
/*!
   \brief Copy areas as polygons (OGR/PostGIS simple features access only)
 
   \param In input vector map
   \param field layer number (-1 for all layers)
   \param Out output vector map
 
   \return 0 on success
   \return 1 on error
 */
int Vect__copy_areas(struct Map_info *In, int field, struct Map_info *Out)
{
    int i, area, nareas, cat, isle, nisles, nparts_alloc, nskipped;
    int ret = 0;
    struct line_pnts **Points;
    struct line_cats *Cats;
 
    /* allocate points & cats */
    Points = (struct line_pnts **)G_malloc(sizeof(struct line_pnts *));
    Points[0] = Vect_new_line_struct();
    nparts_alloc = 1;
    Cats = Vect_new_cats_struct();
 
    /* copy areas */
    nskipped = 0;
    nareas = Vect_get_num_areas(In);
    if (nareas > 0)
        G_message(_("Exporting areas..."));
    for (area = 1; area <= nareas; area++) {
        G_debug(2, "area = %d", area);
        G_percent(area, nareas, 3);
 
        /* get category */
        Vect_reset_cats(Cats);
        if (field > 0) {
            cat = Vect_get_area_cat(In, area, field);
            /* skip area without category in given layer
               if (cat == -1) {
               nskipped++;
               continue;
               }
             */
 
            if (cat > 0)
                Vect_cat_set(Cats, field, cat);
        }
 
        /* skip isles */
        if (Vect_get_area_centroid(In, area) == 0) {
            /* no centroid - check if area forms an isle */
            /* this check does not make sense because the area is also
             * not exported if it is part of an isle inside another
             * area: the isle gets exported as an inner ring
             if (!is_isle(In, area))
             G_warning(_("No centroid defined for area %d. "
             "Area not exported."),
             area);
             */
            G_debug(3, "Area %d: is_isle() -> %d", area, is_isle(In, area));
            continue;
        }
 
        /* get outer ring (area) */
        Vect_get_area_points(In, area, Points[0]);
 
        /* get inner rings (isles) */
        nisles = Vect_get_area_num_isles(In, area);
        if (nisles + 1 > nparts_alloc) {
            /* reallocate space for isles */
            Points = (struct line_pnts **)G_realloc(
                Points, (nisles + 1) * sizeof(struct line_pnts *));
            for (i = nparts_alloc; i < nisles + 1; i++)
                Points[i] = Vect_new_line_struct();
            nparts_alloc = nisles + 1;
        }
        G_debug(3, "\tcat=%d, nisles=%d", cat, nisles);
        for (i = 0; i < nisles; i++) {
            isle = Vect_get_area_isle(In, area, i);
            Vect_get_isle_points(In, isle, Points[i + 1]);
        }
 
        if (In != Out) {
            if (0 > V2__write_area_sfa(Out, (const struct line_pnts **)Points,
                                       nisles + 1, Cats)) {
                G_warning(_("Writing area %d failed"), area);
                ret = -1;
                goto free_exit;
            }
        }
#ifdef HAVE_POSTGRES
        else { /* building simple features geometry from topogeometry data */
            if (0 > V2__update_area_pg(Out, (const struct line_pnts **)Points,
                                       nisles + 1, cat)) {
                G_warning(_("Writing area %d failed"), area);
                ret = -1;
                goto free_exit;
            }
        }
#endif
    }
 
    if (nskipped > 0)
        G_important_message(
            _("%d areas without category or from different layer skipped"),
            nskipped);
 
    /* free allocated space for isles */
free_exit:
    for (i = 0; i < nparts_alloc; i++)
        Vect_destroy_line_struct(Points[i]);
    Vect_destroy_cats_struct(Cats);
    G_free(Points);
 
    return ret;
}
 
/*!
   \brief Copy attribute tables linked to vector map.
 
   Copy all attribute tables linked to the vector map if
   <em>field</em> is 0, or selected attribute table defined by given
   field if <em>field</em> > 0.
 
   Notice, that if input vector map has no tables defined, it will
   copy nothing and return 0 (success).
 
   \param In input vector map
   \param[out] Out output vector map
   \param field layer number (0 for all tables linked to the vector map)
 
   \return 0 on success
   \return -1 on error
 */
int Vect_copy_tables(struct Map_info *In, struct Map_info *Out, int field)
{
    int i, n, type;
    struct field_info *Fi;
    const char *map_name = NULL;
 
    n = Vect_get_num_dblinks(In);
 
    G_debug(2, "Vect_copy_tables(): copying %d tables", n);
 
    type = GV_1TABLE;
    if (field < 1 && n > 1)
        type = GV_MTABLE;
 
    for (i = 0; i < n; i++) {
        Fi = Vect_get_dblink(In, i);
        if (Fi == NULL) {
            G_warning(_("Database connection not defined for layer %d"),
                      In->dblnk->field[i].number);
            return -1;
        }
        if (field > 0 && Fi->number != field) {
            Vect_destroy_field_info(Fi);
            continue;
        }
 
        if (Vect_copy_table(In, Out, Fi->number, Fi->number, Fi->name, type) !=
            0) {
            map_name = Vect_get_full_name(In);
            G_warning(
                _("Unable to copy table <%s> for layer %d from <%s> to <%s>"),
                Fi->table, Fi->number, map_name, Vect_get_name(Out));
            G_free((void *)map_name);
            Vect_destroy_field_info(Fi);
            return -1;
        }
        Vect_destroy_field_info(Fi);
    }
    return 0;
}
 
/*!
   \brief Copy attribute table linked to vector map based on type.
 
   \param In input vector map
   \param[out] Out output vector map
   \param field_in input layer number
   \param field_out output layer number
   \param field_name layer name (can be NULL)
   \param type how many tables are linked to map: GV_1TABLE / GV_MTABLE
 
   \return 0 on success
   \return -1 on error
 */
int Vect_copy_table(struct Map_info *In, struct Map_info *Out, int field_in,
                    int field_out, const char *field_name, int type)
{
    return Vect_copy_table_by_cats(In, Out, field_in, field_out, field_name,
                                   type, NULL, 0);
}
 
/*!
   \brief Copy attribute table linked to vector map based on category
   list.
 
   If <em>cat_list</em> is NULL, then Vect_copy_table() is called.
 
   \param In input vector map
   \param[out] Out output vector map
   \param field_in input layer number
   \param field_out output layer number
   \param field_name layer name (can be NULL)
   \param type how many tables are linked to map: GV_1TABLE / GV_MTABLE
   \param cat_list pointer to cat_list struct (can be NULL)
 
   \return 0 on success
   \return -1 on error
 */
int Vect_copy_table_by_cat_list(struct Map_info *In, struct Map_info *Out,
                                int field_in, int field_out,
                                const char *field_name, int type,
                                const struct cat_list *cat_list)
{
    int *cats;
    int ncats, ret;
 
    if (cat_list) {
        if (Vect_cat_list_to_array(cat_list, &cats, &ncats) != 0)
            return -1;
 
        ret = Vect_copy_table_by_cats(In, Out, field_in, field_out, field_name,
                                      type, cats, ncats);
 
        G_free(cats);
    }
    else {
        ret = Vect_copy_table(In, Out, field_in, field_out, field_name, type);
    }
 
    return ret;
}
 
/*!
   \brief Copy attribute table linked to vector map based on category
   numbers.
 
   \param In input vector map
   \param[out] Out output vector map
   \param field_in input layer number
   \param field_out output layer number
   \param field_name layer name (can be NULL)
   \param type how many tables are linked to map: GV_1TABLE / GV_MTABLE
   \param cats pointer to array of cats or NULL
   \param ncats number of cats in 'cats'
 
   \return 0 on success
   \return -1 on error
 */
int Vect_copy_table_by_cats(struct Map_info *In, struct Map_info *Out,
                            int field_in, int field_out, const char *field_name,
                            int type, int *cats, int ncats)
{
    int ret = 0;
    struct field_info *Fi, *Fin;
    const char *name, *key;
    dbDriver *driver = NULL;
 
    G_debug(2, "Vect_copy_table_by_cats(): field_in = %d field_out = %d",
            field_in, field_out);
 
    Fi = Vect_get_field(In, field_in);
    if (Fi == NULL) {
        G_warning(_("Database connection not defined for layer %d"), field_in);
        return -1;
    }
 
    if (field_name != NULL)
        name = field_name;
    else
        name = Fi->name;
 
    Fin = Vect_default_field_info(Out, field_out, name, type);
    G_debug(3, "Copy drv:db:table '%s:%s:%s' to '%s:%s:%s'", Fi->driver,
            Fi->database, Fi->table, Fin->driver, Fin->database, Fin->table);
 
    ret = Vect_map_add_dblink(Out, Fin->number, Fin->name, Fin->table, Fi->key,
                              Fin->database, Fin->driver);
    if (ret == -1) {
        G_warning(_("Unable to add database link for vector map <%s>"),
                  Out->name);
        goto free_exit;
    }
 
    if (cats)
        key = Fi->key;
    else
        key = NULL;
 
    ret = db_copy_table_by_ints(Fi->driver, Fi->database, Fi->table,
                                Fin->driver, Vect_subst_var(Fin->database, Out),
                                Fin->table, key, cats, ncats);
    if (ret == DB_FAILED) {
        G_warning(_("Unable to copy table <%s>"), Fin->table);
        ret = -1;
        goto free_exit;
    }
 
    driver = db_start_driver_open_database(Fin->driver,
                                           Vect_subst_var(Fin->database, Out));
 
    if (!driver) {
        G_warning(_("Unable to open database <%s> with driver <%s>"),
                  Fin->database, Fin->driver);
        ret = -1;
        goto free_exit;
    }
 
    /* do not allow duplicate keys */
    if (db_create_index2(driver, Fin->table, Fi->key) != DB_OK) {
        G_warning(_("Unable to create index"));
        ret = -1;
        goto close_db_free_exit;
    }
 
    if (db_grant_on_table(driver, Fin->table, DB_PRIV_SELECT,
                          DB_GROUP | DB_PUBLIC) != DB_OK) {
        G_warning(_("Unable to grant privileges on table <%s>"), Fin->table);
        ret = -1;
        goto close_db_free_exit;
    }
 
close_db_free_exit:
    db_close_database_shutdown_driver(driver);
 
free_exit:
    Vect_destroy_field_info(Fi);
    Vect_destroy_field_info(Fin);
 
    return ret;
}