open_ogr.c

Go to the documentation of this file.

/*!
   \file lib/vector/Vlib/open_ogr.c
 
   \brief Vector library - Open OGR layer as vector map layer
 
   Higher level functions for reading/writing/manipulating vectors.
 
   SPDX-FileCopyrightText: 2001-2010 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.0 Martin Landa <landa.martin gmail.com> (2009)
 */
 
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
 
#include <grass/vector.h>
#include <grass/dbmi.h>
#include <grass/glocale.h>
 
#include <ogr_api.h>
 
/*!
   \brief Open existing OGR layer on non-topological level
 
   Note: Map->name, Map->mapset, Map->fInfo.ogr.dsn and
   Map->fInfo.ogr.layer_name must be set before.
 
   \param[in,out] Map pointer to Map_info structure
   \param update TRUE for write mode, otherwise read-only
 
   \return 0 success
   \return -1 error
 */
int V1_open_old_ogr(struct Map_info *Map, int update)
{
    int i, layer, nLayers;
 
    struct Format_info_ogr *ogr_info;
 
    OGRDataSourceH Ogr_ds;
    OGRLayerH Ogr_layer;
    OGRFeatureDefnH Ogr_featuredefn;
    OGRwkbGeometryType Ogr_geom_type;
 
    Ogr_layer = NULL;
    Ogr_geom_type = wkbUnknown;
 
    ogr_info = &(Map->fInfo.ogr);
    if (!ogr_info->dsn) {
        G_fatal_error(_("OGR datasource not defined"));
        return -1;
    }
 
    if (!ogr_info->layer_name) {
        G_fatal_error(_("OGR layer not defined"));
        return -1;
    }
 
    G_debug(2, "V1_open_old_ogr(): dsn = %s layer = %s", ogr_info->dsn,
            ogr_info->layer_name);
 
    OGRRegisterAll();
 
    /* open data source handle */
    Ogr_ds = OGROpen(ogr_info->dsn, FALSE, NULL);
    if (Ogr_ds == NULL)
        G_fatal_error(_("Unable to open OGR data source '%s'"), ogr_info->dsn);
    ogr_info->ds = Ogr_ds;
 
    /* get layer number */
    layer = -1;
    nLayers = OGR_DS_GetLayerCount(Ogr_ds);
    G_debug(2, "%d layers found in data source", nLayers);
 
    for (i = 0; i < nLayers; i++) {
        Ogr_layer = OGR_DS_GetLayer(Ogr_ds, i);
        Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
        if (strcmp(OGR_FD_GetName(Ogr_featuredefn), ogr_info->layer_name) ==
            0) {
            Ogr_geom_type = OGR_FD_GetGeomType(Ogr_featuredefn);
            layer = i;
            break;
        }
    }
    if (layer == -1) {
        OGR_DS_Destroy(Ogr_ds);
        G_fatal_error(_("OGR layer <%s> not found"), ogr_info->layer_name);
    }
    G_debug(2, "OGR layer %d opened", layer);
 
    ogr_info->layer = Ogr_layer;
    if (update && OGR_L_TestCapability(ogr_info->layer, OLCTransactions) &&
        (OGR_L_StartTransaction(ogr_info->layer) != OGRERR_NONE)) {
        OGR_DS_Destroy(Ogr_ds);
        G_warning(_("OGR transaction with layer <%s> failed to start"),
                  ogr_info->layer_name);
        return -1;
    }
 
    switch (Ogr_geom_type) {
    case wkbPoint25D:
    case wkbLineString25D:
    case wkbPolygon25D:
    case wkbMultiPoint25D:
    case wkbMultiLineString25D:
    case wkbMultiPolygon25D:
    case wkbGeometryCollection25D:
        Map->head.with_z = WITH_Z;
        break;
    default:
        Map->head.with_z = WITHOUT_Z;
        break;
    }
 
    ogr_info->cache.fid = -1; /* FID >= 0 */
 
    return 0;
}
 
/*!
   \brief Open existing OGR layer on topological level
 
   This functions reads feature index (fidx) file required for
   pseudo-topology.
 
   \param[in,out] Map pointer to Map_info structure
 
   \return 0 success
   \return -1 error
 */
int V2_open_old_ogr(struct Map_info *Map)
{
    G_debug(3, "V2_open_old_ogr(): name = %s mapset = %s", Map->name,
            Map->mapset);
 
    if (Vect_open_fidx(Map, &(Map->fInfo.ogr.offset)) != 0) {
        const char *map_name = Vect_get_full_name(Map);
        G_warning(_("Unable to open feature index file for vector map <%s>"),
                  map_name);
        G_free((void *)map_name);
        G_zero(&(Map->fInfo.ogr.offset), sizeof(struct Format_info_offset));
    }
 
    Map->fInfo.ogr.next_line = 1; /* reset feature cache */
 
    return 0;
}
 
/*!
   \brief Prepare OGR datasource for creating new OGR layer (level 1)
 
   New OGR layer is created when writing features by
   Vect_wrile_line().
 
   \param[out] Map pointer to Map_info structure
   \param name name of OGR layer to create
   \param with_z WITH_Z for 3D vector data otherwise WITHOUT_Z
 
   \return 0 success
   \return -1 error
 */
int V1_open_new_ogr(struct Map_info *Map, const char *name, int with_z)
{
    int i, nlayers;
 
    struct Format_info_ogr *ogr_info;
 
    OGRSFDriverH Ogr_driver;
    OGRDataSourceH Ogr_ds;
    OGRLayerH Ogr_layer;
    OGRFeatureDefnH Ogr_featuredefn;
 
    OGRRegisterAll();
 
    ogr_info = &(Map->fInfo.ogr);
 
    G_debug(1, "V1_open_new_ogr(): name = %s with_z = %d", name, with_z);
    Ogr_driver = OGRGetDriverByName(ogr_info->driver_name);
    if (!Ogr_driver) {
        G_warning(_("Unable to get OGR driver <%s>"), ogr_info->driver_name);
        return -1;
    }
    ogr_info->driver = Ogr_driver;
 
    /* TODO: creation options */
    Ogr_ds = OGR_Dr_CreateDataSource(Ogr_driver, ogr_info->dsn, NULL);
    if (!Ogr_ds) {
        G_warning(_("Unable to create OGR data source '%s'"), ogr_info->dsn);
        return -1;
    }
    ogr_info->ds = Ogr_ds;
 
    nlayers = OGR_DS_GetLayerCount(Ogr_ds);
    for (i = 0; i < nlayers; i++) {
        Ogr_layer = OGR_DS_GetLayer(Ogr_ds, i);
        Ogr_featuredefn = OGR_L_GetLayerDefn(Ogr_layer);
        if (strcmp(OGR_FD_GetName(Ogr_featuredefn), name) == 0) {
            if (G_get_overwrite()) {
                G_warning(
                    _("OGR layer <%s> already exists and will be overwritten"),
                    ogr_info->layer_name);
 
                if (OGR_DS_DeleteLayer(Ogr_ds, i) != OGRERR_NONE) {
                    G_warning(_("Unable to delete OGR layer <%s>"),
                              ogr_info->layer_name);
                    return -1;
                }
            }
            else {
                G_fatal_error(
                    _("OGR layer <%s> already exists in datasource '%s'"),
                    ogr_info->layer_name, ogr_info->dsn);
            }
            ogr_info->layer = NULL;
            break;
        }
    }
 
    return 0;
}
 
/*!
   \brief Open feature index file
 
   \param[in,out] Map pointer to Map_info struct
   \param[out] offset pointer to Format_info_offset (OGR or PG)
 
   \return 0 on success
   \return -1 on error
 */
int Vect_open_fidx(struct Map_info *Map, struct Format_info_offset *offset)
{
    char elem[GPATH_MAX];
    char buf[5]; /* used for format version */
    long length;
    int Version_Major, Version_Minor, Back_Major, Back_Minor, byte_order;
 
    struct gvfile fp;
    struct Port_info port;
 
    G_debug(1, "Vect_open_fidx(): name = %s mapset = %s format = %d", Map->name,
            Map->mapset, Map->format);
 
    snprintf(elem, sizeof(elem), "%s/%s", GV_DIRECTORY, Map->name);
    dig_file_init(&fp);
    fp.file = G_fopen_old(elem, GV_FIDX_ELEMENT, Map->mapset);
    if (fp.file == NULL) {
        const char *map_name = Vect_get_full_name(Map);
        G_debug(1, "unable to open fidx file for vector map <%s>", map_name);
        G_free((void *)map_name);
        return -1;
    }
 
    /* Header */
    if (0 >= dig__fread_port_C(buf, 5, &fp)) {
        fclose(fp.file);
        return -1;
    }
    Version_Major = buf[0];
    Version_Minor = buf[1];
    Back_Major = buf[2];
    Back_Minor = buf[3];
    byte_order = buf[4];
 
    /* check version numbers */
    if (Version_Major > 5 || Version_Minor > 0) {
        if (Back_Major > 5 || Back_Minor > 0) {
            G_fatal_error(_("Feature index format version %d.%d is not "
                            "supported by this release."
                            " Try to rebuild topology or upgrade GRASS."),
                          Version_Major, Version_Minor);
            return -1;
        }
        G_warning(_("Your GRASS version does not fully support feature index "
                    "format %d.%d of the vector."
                    " Consider to rebuild topology or upgrade GRASS."),
                  Version_Major, Version_Minor);
    }
 
    dig_init_portable(&port, byte_order);
    dig_set_cur_port(&port);
 
    /* Body */
    /* bytes 6 - 9 : header size */
    if (0 >= dig__fread_port_L(&length, 1, &fp)) {
        fclose(fp.file);
        return -1;
    }
    G_debug(4, "  header size %ld", length);
 
    G_fseek(fp.file, length, SEEK_SET);
 
    /* number of records  */
    if (0 >= dig__fread_port_I(&(offset->array_num), 1, &fp)) {
        fclose(fp.file);
        return -1;
    }
 
    /* alloc space */
    offset->array = (int *)G_malloc(offset->array_num * sizeof(int));
    offset->array_alloc = offset->array_num;
 
    /* offsets */
    if (0 >= dig__fread_port_I(offset->array, offset->array_num, &fp)) {
        fclose(fp.file);
        return -1;
    }
 
    fclose(fp.file);
 
    G_debug(3, "%d records read from fidx", offset->array_num);
 
    return 0;
}