read_nat.c

Go to the documentation of this file.

/*!
   \file lib/vector/Vlib/read_nat.c
 
   \brief Vector library - reading features (native format)
 
   Higher level functions for reading/writing/manipulating vectors.
 
   SPDX-FileCopyrightText: 2001-2009, 2011-2012 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 by Radim Blazek and David D. Gray.
   \author Update to GRASS 7 by Martin Landa <landa.martin gmail.com>
 */
 
#include <sys/types.h>
#include <grass/vector.h>
#include <grass/glocale.h>
 
static int read_line_nat(struct Map_info *, struct line_pnts *,
                         struct line_cats *, off_t);
 
/*! \brief Read vector feature on non-topological level (level 1) -
   native format - internal use only
 
   This function implements random access for native format,
   constraints are ignored!
 
   \param Map pointer to Map_info struct
   \param[out] Points container used to store line points within
   (pointer to line_pnts struct)
   \param[out] Cats container used to store line categories within
   (pointer to line_cats struct)
   \param offset given offset
 
   \return feature type (GV_POINT, GV_LINE, ...)
   \return 0 dead line
   \return -2 nothing to read
   \return -1 on failure
 */
int V1_read_line_nat(struct Map_info *Map, struct line_pnts *Points,
                     struct line_cats *Cats, off_t offset)
{
    return read_line_nat(Map, Points, Cats, offset);
}
 
/*! \brief Read next vector feature on non-topological level (level
   1) - native format - internal use only.
 
   This function implements sequential access, constraints are
   reflected, see Vect_set_constraint_region(),
   Vect_set_constraint_type(), or Vect_set_constraint_field().
 
   Dead features are skipped.
 
   Vect_rewind() can be used to reset reading.
 
   \param Map pointer to Map_info struct
   \param[out] line_p container used to store line points within
   (pointer to line_pnts struct)
   \param[out] line_c container used to store line categories within
   (pointer to line_cats struct)
 
   \return feature type (GV_POINT, GV_LINE, ...)
   \return 0 dead line
   \return -2 nothing to read
   \return -1 on failure
 */
int V1_read_next_line_nat(struct Map_info *Map, struct line_pnts *line_p,
                          struct line_cats *line_c)
{
    int itype;
    off_t offset;
    struct bound_box lbox, mbox;
 
    G_debug(3, "V1_read_next_line_nat()");
 
    if (Map->constraint.region_flag)
        Vect_get_constraint_box(Map, &mbox);
 
    while (TRUE) {
        offset = dig_ftell(&(Map->dig_fp));
        itype = read_line_nat(Map, line_p, line_c, offset);
        if (itype < 0)
            return itype; /* nothing to read or failure */
 
        if (itype == 0) /* skip dead line */
            continue;
 
        if (Map->constraint.type_flag) {
            /* skip feature by type */
            if (!(itype & Map->constraint.type))
                continue;
        }
 
        if (line_p && Map->constraint.region_flag) {
            /* skip feature by region */
            Vect_line_box(line_p, &lbox);
 
            if (!Vect_box_overlap(&lbox, &mbox))
                continue;
        }
 
        if (line_c && Map->constraint.field_flag) {
            /* skip feature by field */
            if (Vect_cat_get(line_c, Map->constraint.field, NULL) == 0)
                continue;
        }
 
        return itype;
    }
 
    return -1; /* NOTREACHED */
}
 
/*! \brief Read vector feature on topological level (level 2) -
   native format - internal use only
 
   This function implements random access for native format,
   constraints are ignored!
 
   Note: Topology must be built at level >= GV_BUILD_BASE
 
   \param Map pointer to Map_info struct
   \param[out] line_p container used to store line points within (pointer to
                      line_pnts struct)
   \param[out] line_c container used to store line categories
                      within (pointer to line_cats struct)
   \param line feature id to read (starts at 1)
 
   \return feature type (GV_POINT, GV_LINE, ...)
   \return -2 nothing to read
   \return -1 on failure
 */
int V2_read_line_nat(struct Map_info *Map, struct line_pnts *line_p,
                     struct line_cats *line_c, int line)
{
    struct P_line *Line;
 
    G_debug(3, "V2_read_line_nat(): line = %d", line);
 
    if (line < 1 || line > Map->plus.n_lines) {
        G_warning(_("Attempt to access feature with invalid id (%d)"), line);
        return -1;
    }
 
    Line = Map->plus.Line[line];
    if (Line == NULL) {
        G_warning(_("Attempt to access dead feature %d"), line);
        return -1;
    }
 
    return read_line_nat(Map, line_p, line_c, Line->offset);
}
 
/*! \brief Read next vector feature on topological level (level 2) -
   native format - internal use only.
 
   This function implements sequential access, constraints are
   reflected, see Vect_set_constraint_region(),
   Vect_set_constraint_type(), or Vect_set_constraint_field().
 
   Use Vect_rewind() to reset reading.
 
   Dead feature are skipped.
 
   \param Map pointer to Map_info struct
   \param[out] line_p container used to store line points within
   (pointer to line_pnts struct)
   \param[out] line_c container used to store line categories within
   (pointer to line_cats struct)
 
   \return feature type (GV_POINT, GV_LINE, ...)
   \return -2 nothing to read
   \return -1 on error
 */
int V2_read_next_line_nat(struct Map_info *Map, struct line_pnts *line_p,
                          struct line_cats *line_c)
{
    int line, ret;
    struct P_line *Line;
    struct bound_box lbox, mbox;
 
    G_debug(3, "V2_read_next_line_nat()");
 
    if (Map->constraint.region_flag)
        Vect_get_constraint_box(Map, &mbox);
 
    while (TRUE) {
        line = Map->next_line;
 
        if (line > Map->plus.n_lines)
            return -2; /* nothing to read */
 
        Line = Map->plus.Line[line];
        if (Line == NULL) {
            /* skip dead line */
            Map->next_line++;
            continue;
        }
 
        if (Map->constraint.type_flag) {
            /* skip feature by type */
            if (!(Line->type & Map->constraint.type)) {
                Map->next_line++;
                continue;
            }
        }
 
        Map->next_line++;
        ret = read_line_nat(Map, line_p, line_c, Line->offset);
        if (ret < 0)
            return ret;
 
        if (line_p && Map->constraint.region_flag) {
            /* skip feature by bbox */
            Vect_line_box(line_p, &lbox);
 
            if (!Vect_box_overlap(&lbox, &mbox))
                continue;
        }
 
        if (line_c && Map->constraint.field_flag) {
            /* skip feature by field */
            if (Vect_cat_get(line_c, Map->constraint.field, NULL) == 0)
                continue;
        }
 
        return ret;
    }
 
    return -1; /* NOTREACHED */
}
 
/*!
   \brief Read line from coor file
 
   \param Map vector map layer
   \param[out] p container used to store line points within
   \param[out] c container used to store line categories within
   \param offset given offset
 
   \return line type ( > 0 )
   \return 0 dead line
   \return -1 out of memory
   \return -2 end of file
 */
int read_line_nat(struct Map_info *Map, struct line_pnts *p,
                  struct line_cats *c, off_t offset)
{
    register int i, dead = 0;
    int n_points;
    off_t size;
    int n_cats, do_cats;
    int type;
    char rhead, nc;
    short field;
 
    G_debug(3, "Vect__Read_line_nat: offset = %lu", (unsigned long)offset);
 
    Map->head.last_offset = offset;
 
    /* reads must set in_head, but writes use default */
    dig_set_cur_port(&(Map->head.port));
 
    dig_fseek(&(Map->dig_fp), offset, 0);
 
    if (0 >= dig__fread_port_C(&rhead, 1, &(Map->dig_fp)))
        return (-2);
 
    if (!(rhead & 0x01)) /* dead line */
        dead = 1;
 
    if (rhead & 0x02) /* categories exists */
        do_cats =
            1; /* do not return here let file offset moves forward to next */
    else       /* line */
        do_cats = 0;
 
    rhead >>= 2;
    type = dig_type_from_store((int)rhead);
 
    G_debug(3, "    type = %d, do_cats = %d dead = %d", type, do_cats, dead);
 
    if (c != NULL)
        c->n_cats = 0;
 
    if (do_cats) {
        if (Map->head.coor_version.minor == 1) { /* coor format 5.1 */
            if (0 >= dig__fread_port_I(&n_cats, 1, &(Map->dig_fp)))
                return (-2);
        }
        else { /* coor format 5.0 */
            if (0 >= dig__fread_port_C(&nc, 1, &(Map->dig_fp)))
                return (-2);
            n_cats = (int)nc;
        }
        G_debug(3, "    n_cats = %d", n_cats);
 
        if (c != NULL) {
            c->n_cats = n_cats;
            if (n_cats > 0) {
                if (0 > dig_alloc_cats(c, (int)n_cats + 1))
                    return -1;
 
                if (Map->head.coor_version.minor == 1) { /* coor format 5.1 */
                    if (0 >=
                        dig__fread_port_I(c->field, n_cats, &(Map->dig_fp)))
                        return (-2);
                }
                else { /* coor format 5.0 */
                    for (i = 0; i < n_cats; i++) {
                        if (0 >= dig__fread_port_S(&field, 1, &(Map->dig_fp)))
                            return (-2);
                        c->field[i] = (int)field;
                    }
                }
                if (0 >= dig__fread_port_I(c->cat, n_cats, &(Map->dig_fp)))
                    return (-2);
            }
        }
        else {
            if (Map->head.coor_version.minor == 1) { /* coor format 5.1 */
                size = (off_t)(2 * PORT_INT) * n_cats;
            }
            else { /* coor format 5.0 */
                size = (off_t)(PORT_SHORT + PORT_INT) * n_cats;
            }
 
            dig_fseek(&(Map->dig_fp), size, SEEK_CUR);
        }
    }
 
    if (type & GV_POINTS) {
        n_points = 1;
    }
    else {
        if (0 >= dig__fread_port_I(&n_points, 1, &(Map->dig_fp)))
            return (-2);
    }
 
    G_debug(3, "    n_points = %d", n_points);
 
    if (p != NULL) {
        if (0 > dig_alloc_points(p, n_points + 1))
            return (-1);
 
        p->n_points = n_points;
        if (0 >= dig__fread_port_D(p->x, n_points, &(Map->dig_fp)))
            return (-2);
        if (0 >= dig__fread_port_D(p->y, n_points, &(Map->dig_fp)))
            return (-2);
 
        if (Map->head.with_z) {
            if (0 >= dig__fread_port_D(p->z, n_points, &(Map->dig_fp)))
                return (-2);
        }
        else {
            for (i = 0; i < n_points; i++)
                p->z[i] = 0.0;
        }
    }
    else {
        if (Map->head.with_z)
            size = (off_t)n_points * 3 * PORT_DOUBLE;
 
        else
            size = (off_t)n_points * 2 * PORT_DOUBLE;
 
        dig_fseek(&(Map->dig_fp), size, SEEK_CUR);
    }
 
    G_debug(3, "    off = %lu", (unsigned long)dig_ftell(&(Map->dig_fp)));
 
    if (dead)
        return 0;
 
    return type;
}