vector/Vlib/header.c

Go to the documentation of this file.

/*!
   \file lib/vector/Vlib/header.c
 
   \brief Vector library - header manipulation
 
   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 (OGR support) by Martin Landa <landa.martin
   gmail.com>
 */
 
#include <stdlib.h>
#include <string.h>
#include <grass/vector.h>
#include <grass/glocale.h>
 
#include "local_proto.h"
 
/*!
   \brief Print vector map header to stdout
 
   \param Map pointer to Map_info structure
 
   \return 0 on success
 */
int Vect_print_header(struct Map_info *Map)
{
    fprintf(stdout, "\nSelected information from dig header\n");
    fprintf(stdout, " Organization:  %s\n", Vect_get_organization(Map));
    fprintf(stdout, " Map Name:      %s\n", Vect_get_map_name(Map));
    fprintf(stdout, " Source Date:   %s\n", Vect_get_map_date(Map));
    fprintf(stdout, " Orig. Scale:   %d\n", Vect_get_scale(Map));
 
    return 0;
}
 
/*!
   \brief Read vector map header from map head file
 
   \param Map pointrt to Map_info structure
 
   \return 0
 */
int Vect_read_header(struct Map_info *Map)
{
    Vect__read_head(Map);
    return 0;
}
 
/*!
   \brief Write vector map header to map head file
 
   \param Map pointer to Map_info structure
 
   \return 0
 */
int Vect_write_header(struct Map_info *Map)
{
    /* do some sanity checking here */
    Vect__write_head(Map);
    return 0;
}
 
/*!
   \brief Writes head information to text file (GV_HEAD_ELEMENT)
 
   \param Map pointer to Map_info structure
 
   \return 0 on success
   \return -1 on error
 */
int Vect__write_head(struct Map_info *Map)
{
    char path[GPATH_MAX];
    FILE *head_fp;
 
    Vect__get_path(path, Map);
    head_fp = G_fopen_new(path, GV_HEAD_ELEMENT);
    if (head_fp == NULL) {
        const char *map_name = Vect_get_full_name(Map);
        G_warning(_("Unable to create header file for vector map <%s>"),
                  map_name);
        G_free((void *)map_name);
        return -1;
    }
 
    fprintf(head_fp, "ORGANIZATION: %s\n", Vect_get_organization(Map));
    fprintf(head_fp, "DIGIT DATE:   %s\n", Vect_get_date(Map));
    fprintf(head_fp, "DIGIT NAME:   %s\n", Vect_get_person(Map));
    fprintf(head_fp, "MAP NAME:     %s\n", Vect_get_map_name(Map));
    fprintf(head_fp, "MAP DATE:     %s\n", Vect_get_map_date(Map));
    fprintf(head_fp, "MAP SCALE:    %d\n", Vect_get_scale(Map));
    fprintf(head_fp, "OTHER INFO:   %s\n", Vect_get_comment(Map));
    if (Vect_get_proj(Map) > 0)
        fprintf(head_fp, "PROJ:         %d\n", Vect_get_proj(Map));
    fprintf(head_fp, "ZONE:         %d\n", Vect_get_zone(Map));
    fprintf(head_fp, "MAP THRESH:   %f\n", Vect_get_thresh(Map));
 
    fclose(head_fp);
 
    return 0;
}
 
/*!
   \brief Reads head information from text file (GV_HEAD_ELEMENT) - for internal
   use only
 
   \param Map pointer to Map_info structure
 
   \return 0 on success
   \return -1 on error
 */
int Vect__read_head(struct Map_info *Map)
{
    FILE *head_fp;
    char buff[2000];
    char path[GPATH_MAX], *ptr;
 
    /* Reset / init */
    Vect__init_head(Map);
 
    G_debug(1, "Vect__read_head(): vector = %s@%s", Map->name, Map->mapset);
    Vect__get_path(path, Map);
    head_fp = G_fopen_old(path, GV_HEAD_ELEMENT, Map->mapset);
    if (head_fp == NULL) {
        const char *map_name = Vect_get_full_name(Map);
        G_warning(_("Unable to open header file of vector <%s>"), map_name);
        G_free((void *)map_name);
        return -1;
    }
 
    while (G_getl2(buff, 2000, head_fp)) {
 
        if (!(ptr = strchr(buff, ':'))) {
            G_warning(_("Corrupted row in head: %s"), buff);
            continue;
        }
 
        ptr++; /* Search for the start of text */
        while (*ptr == ' ')
            ptr++;
 
        if (strncmp(buff, "ORGANIZATION:", sizeof(char) * 13) == 0)
            Vect_set_organization(Map, ptr);
        else if (strncmp(buff, "DIGIT DATE:", sizeof(char) * 11) == 0)
            Vect_set_date(Map, ptr);
        else if (strncmp(buff, "DIGIT NAME:", sizeof(char) * 11) == 0)
            Vect_set_person(Map, ptr);
        else if (strncmp(buff, "MAP NAME:", sizeof(char) * 9) == 0)
            Vect_set_map_name(Map, ptr);
        else if (strncmp(buff, "MAP DATE:", sizeof(char) * 9) == 0)
            Vect_set_map_date(Map, ptr);
        else if (strncmp(buff, "MAP SCALE:", sizeof(char) * 10) == 0)
            Vect_set_scale(Map, atoi(ptr));
        else if (strncmp(buff, "OTHER INFO:", sizeof(char) * 11) == 0)
            Vect_set_comment(Map, ptr);
        else if (strncmp(buff, "PROJ:", sizeof(char) * 5) == 0)
            Vect_set_proj(Map, atoi(ptr));
        else if (strncmp(buff, "ZONE:", sizeof(char) * 5) == 0 ||
                 strncmp(buff, "UTM ZONE:", sizeof(char) * 9) == 0)
            Vect_set_zone(Map, atoi(ptr));
        else if (strncmp(buff, "WEST EDGE:", sizeof(char) * 10) == 0) {
        }
        else if (strncmp(buff, "EAST EDGE:", sizeof(char) * 10) == 0) {
        }
        else if (strncmp(buff, "SOUTH EDGE:", sizeof(char) * 11) == 0) {
        }
        else if (strncmp(buff, "NORTH EDGE:", sizeof(char) * 11) == 0) {
        }
        else if (strncmp(buff, "MAP THRESH:", sizeof(char) * 11) == 0)
            Vect_set_thresh(Map, atof(ptr));
        else
            G_warning(_("Unknown keyword '%s' in vector head"), buff);
    }
 
    fclose(head_fp);
 
    return 0;
}
 
/*!
   \brief Get name of vector map
 
   \param Map pointer to Map_info structure
 
   \return string containing name
 */
const char *Vect_get_name(struct Map_info *Map)
{
    return Map->name;
}
 
/*!
   \brief Get name of mapset where vector map lives
 
   \param Map pointer to Map_info structure
 
   \return string containing mapset name
 */
const char *Vect_get_mapset(struct Map_info *Map)
{
    return Map->mapset;
}
 
/*!
   \brief Get fully qualified name of vector map
 
   - for GV_FORMAT_NATIVE and GV_FORMAT_OGR returns "map@mapset"
   - for GV_FORMAT_OGR_DIRECT returns "layer@datasourse"
 
   Allocated string should be freed by G_free().
 
   \param Map pointer to Map_info structure
 
   \return allocated string "name@mapset"
 */
const char *Vect_get_full_name(struct Map_info *Map)
{
    char *ptr;
    size_t len;
 
    if (Map->format == GV_FORMAT_OGR_DIRECT && Map->fInfo.ogr.dsn &&
        Map->fInfo.ogr.layer_name) {
        len =
            strlen(Map->fInfo.ogr.layer_name) + strlen(Map->fInfo.ogr.dsn) + 2;
        ptr = (char *)G_malloc(len);
        snprintf(ptr, len, "%s@%s", Map->fInfo.ogr.layer_name,
                 Map->fInfo.ogr.dsn);
 
        return ptr;
    }
 
    len = strlen(Map->name) + strlen(Map->mapset) + 2;
    ptr = (char *)G_malloc(len);
    if (strlen(Map->mapset) > 0) {
        snprintf(ptr, len, "%s@%s", Map->name, Map->mapset);
    }
    else {
        snprintf(ptr, len, "%s", Map->name);
    }
 
    return ptr;
}
 
/*!
   \brief Check if vector map is 3D
 
   Check vector map header.
 
   \param Map pointer to Map_info structure
 
   \return TRUE  vector map is 3D
   \return FALSE vector map is not 3D
 */
int Vect_is_3d(struct Map_info *Map)
{
    return Map->head.with_z;
}
 
/*!
   \brief Set organization string in map header
 
   \param Map pointer to Map_info structure
   \param str organization name
 
   \return 0
 */
int Vect_set_organization(struct Map_info *Map, const char *str)
{
    G_free(Map->head.organization);
    Map->head.organization = G_store(str);
 
    return 0;
}
 
/*!
   \brief Get organization string from map header
 
   \param Map pointer to Map_info structure
 
   \return string containing organization name
 */
const char *Vect_get_organization(struct Map_info *Map)
{
    return Map->head.organization;
}
 
/*!
   \brief Set date of digitization in map header
 
   \todo This should be coupled to DateTime functions to support
   time series
 
   \param Map pointer to Map_info structure
   \param str date given as string
 
   \return 0
 */
int Vect_set_date(struct Map_info *Map, const char *str)
{
    G_free(Map->head.date);
    Map->head.date = G_store(str);
 
    return 0;
}
 
/*!
   \brief Get date of digitization from map header
 
   \param Map pointer to Map_info structure
 
   \return date of digitization string
 */
const char *Vect_get_date(struct Map_info *Map)
{
    return (Map->head.date);
}
 
/*!
   \brief Set name of user who digitized the map in map header
 
   \param Map pointer to Map_info structure
   \param str user name
 
   \return 0
 */
int Vect_set_person(struct Map_info *Map, const char *str)
{
    G_free(Map->head.user_name);
    Map->head.user_name = G_store(str);
 
    return 0;
}
 
/*!
   \brief Get user name string who digitized the map from map header
 
   \param Map pointer to Map_info structure
 
   \return string containing user name
 */
const char *Vect_get_person(struct Map_info *Map)
{
    return (Map->head.user_name);
}
 
/*!
   \brief Set map name in map header
 
   \param Map pointer to Map_info structure
   \param str map name to be set
 
   \return 0
 */
int Vect_set_map_name(struct Map_info *Map, const char *str)
{
    G_free(Map->head.map_name);
    Map->head.map_name = G_store(str);
 
    return 0;
}
 
/*!
   \brief Get map name from map header
 
   \param Map pointer to Map_info structure
 
   \return string containing map name
 */
const char *Vect_get_map_name(struct Map_info *Map)
{
    return Map->head.map_name;
}
 
/*!
   \brief Set date when the source map was originally produced in map header
 
   \param Map pointer to Map_info structure
   \param str date given as a string
 
   \return 0
 */
int Vect_set_map_date(struct Map_info *Map, const char *str)
{
    G_free(Map->head.source_date);
    Map->head.source_date = G_store(str);
 
    return 0;
}
 
/*!
   \brief Get date when the source map was originally produced from map header
 
   \param Map pointer to Map_info structure
 
   \return string containing a date
 */
const char *Vect_get_map_date(struct Map_info *Map)
{
    return Map->head.source_date;
}
 
/*!
   \brief Set map scale in map header
 
   \param Map pointer to Map_info structure
   \param scale map scale
 
   \return 0
 */
int Vect_set_scale(struct Map_info *Map, int scale)
{
    Map->head.orig_scale = scale;
 
    return 0;
}
 
/*!
   \brief Get map scale from map header
 
   \param Map pointer to Map_info structure
 
   \return map scale
 */
int Vect_get_scale(struct Map_info *Map)
{
    return (int)Map->head.orig_scale;
}
 
/*!
   \brief Set comment or other info string in map header
 
   \param Map pointer to Map_info structure
   \param str comment or other info string
 
   \return 0
 */
int Vect_set_comment(struct Map_info *Map, const char *str)
{
    G_free(Map->head.comment);
    Map->head.comment = G_store(str);
 
    return 0;
}
 
/*!
   \brief Get comment or other info string from map header
 
   \param Map pointer to Map_info structure
 
   \return comment or other info string
 */
const char *Vect_get_comment(struct Map_info *Map)
{
    return (Map->head.comment);
}
 
/*!
   \brief Set projection zone in map header
 
   \param Map pointer to Map_info structure
   \param zone projection zone
 
   \return 0
 */
int Vect_set_zone(struct Map_info *Map, int zone)
{
    Map->head.plani_zone = zone;
 
    return 0;
}
 
/*!
   \brief Get projection zone from map header
 
   \param Map pointer to Map_info structure (unused, returns the zone for
          the active region)
 
   \return projection zone
 */
int Vect_get_zone(struct Map_info *Map G_UNUSED)
{
    /* return Map->head.plani_zone; */
 
    /* use utm zone of current location,
     * a vector in a given location can not be in a different CRS */
    return G_zone();
}
 
/*!
   \brief Set projection in map header
 
   Supported projections:
   - PROJECTION_XY  0 - x,y (Raw imagery),
   - PROJECTION_UTM 1 - UTM   Universal Transverse Mercator,
   - PROJECTION_LL  3 - Latitude-Longitude
 
   \param Map pointer to Map_info structure
   \param proj projection code
 
   \return 0
 */
int Vect_set_proj(struct Map_info *Map, int proj)
{
    Map->head.proj = proj;
 
    return 0;
}
 
/*!
   \brief Get projection from map header
 
   \param Map pointer to Map_info structure
 
   \return PROJECTION_XY  0 - x,y (Raw imagery),
   \return PROJECTION_UTM 1 - UTM   Universal Transverse Mercator,
   \return PROJECTION_LL  3 - Latitude-Longitude
 */
int Vect_get_proj(struct Map_info *Map)
{
    return (Map->head.proj);
}
 
/*!
   \brief Query cartographic projection name of pointer to Map_info structure
 
   Returns a pointer to a string which is a printable name for
   projection code <em>proj</em> (as returned by Vect_get_proj()).
 
   \param Map pointer to Map_info structure
 
   \return allocated string containing projection name
   \return NULL if <em>proj</em> is not a valid projection
 */
const char *Vect_get_proj_name(struct Map_info *Map)
{
    char name[256];
    int n;
 
    switch (n = Vect_get_proj(Map)) {
    case PROJECTION_XY:
    case PROJECTION_UTM:
    case PROJECTION_LL:
        return G_projection_name(n);
    case PROJECTION_OTHER:
        /* this won't protect against differing "other" projections, so
           better to just include P_OTHER in the above list so we return the
           strictly more correct, but less nice, string: "Other projection" ? */
        return G_database_projection_name();
    default:
        G_debug(1,
                "Vect_get_proj_name(): "
                "Vect_get_proj() returned an invalid result (%d)",
                n);
        break;
    }
 
    strcpy(name, _("Unknown projection"));
    return G_store(name);
}
 
/*!
   \brief Set threshold used for digitization in map header
 
   \param Map pointer to Map_info structure
   \param thresh threshold used for digitization
 
   \return 0
 */
int Vect_set_thresh(struct Map_info *Map, double thresh)
{
    G_debug(1, "Vect_set_thresh(): thresh = %f", thresh);
    Map->head.digit_thresh = thresh;
    return 0;
}
 
/*!
   \brief Get threshold used for digitization from map header
 
   \param Map pointer to Map_info structure
 
   \return threshold used for digitization
 */
double Vect_get_thresh(struct Map_info *Map)
{
    return Map->head.digit_thresh;
}