Gp3.c

Go to the documentation of this file.

#include <stdlib.h>

#include <grass/gis.h>
#include <grass/site.h>
#include <grass/Vect.h>
#include <grass/glocale.h>
#include <grass/gstypes.h>

int Gp_set_color(const char *grassname, geopoint * gp)
{
    const char *col_map;
    struct Colors sc;
    CELL cat;
    geopoint *tp;
    int r, g, b, color;

    /* TODO: handle error messages */

    if (grassname) {
        col_map = G_find_cell2(grassname, "");
        if (!col_map) {
            G_warning(_("Raster map <%s> not found"), grassname);
            return 0;
        }

        G_read_colors(grassname, col_map, &sc);

        for (tp = gp; tp; tp = tp->next) {
            cat = (int)tp->fattr;
            color = NULL_COLOR;

            if (G_get_color(cat, &r, &g, &b, &sc)) {
                color = (r & 0xff) | ((g & 0xff) << 8) | ((b & 0xff) << 16);
            }

            tp->iattr = color;
        }

        return (1);
    }

    return (0);
}

geopoint *Gp_load_sites(const char *grassname, int *nsites, int *has_z,
                        int *has_att)
{
    struct Map_info map;
    static struct line_pnts *Points = NULL;
    static struct line_cats *Cats = NULL;
    geopoint *top, *gpt, *prev;
    int np, ltype, eof;
    struct Cell_head wind;
    RASTER_MAP_TYPE rtype;
    int ndim;
    const char *mapset;

    np = 0;
    eof = 0;
    *has_z = *has_att = 0;

    mapset = G_find_vector2(grassname, "");
    if (!mapset) {
        G_warning(_("Vector map <%s> not found"), grassname);
        return NULL;
    }

    Vect_set_open_level(2);
    if (Vect_open_old(&map, grassname, "") == -1) {
        G_fatal_error(_("Unable to open vector map <%s>"),
                      G_fully_qualified_name(grassname, mapset));
    }

    Points = Vect_new_line_struct();
    Cats = Vect_new_cats_struct();

    top = gpt = (geopoint *) G_malloc(sizeof(geopoint));
    if (!top) {
        return (NULL);
    }

    G_get_set_window(&wind);
    Vect_set_constraint_region(&map, wind.north, wind.south, wind.east,
                               wind.west, PORT_DOUBLE_MAX, -PORT_DOUBLE_MAX);

    /* get ndim */
    ndim = 2;
    if (Vect_is_3d(&map)) {
        ndim = 3;
    }

    /* set rtype */
    rtype = CELL_TYPE;

    while (eof == 0) {
        ltype = Vect_read_next_line(&map, Points, Cats);
        switch (ltype) {
        case -1:
            {
                G_warning(_("Unable to read vector map <%s>"),
                          G_fully_qualified_name(grassname, mapset));
                return (NULL);
            }
        case -2:                /* EOF */
            {
                eof = 1;
                continue;
            }
        }
        if ((ltype & GV_POINTS)) {
            np++;
            gpt->p3[X] = Points->x[0];
            gpt->p3[Y] = Points->y[0];

            if (ndim > 2) {
                *has_z = 1;
                gpt->dims = 3;
                gpt->p3[Z] = Points->z[0];
            }
            else {
                gpt->dims = 2;
                *has_z = 0;
            }

            if (Cats->n_cats > 0) {
                *has_att = 1;
                gpt->fattr = Cats->field[0];    /* Is this correct? */
                /* gpt->cat = ; ??** */
                gpt->highlight_color = gpt->highlight_size =
                    gpt->highlight_marker = FALSE;
            }
            else {
                gpt->fattr = 0;
                *has_att = 0;
            }

            gpt->iattr = gpt->fattr;
            gpt->cattr = NULL;

            G_debug(3, "loading vector point %d %f %f -- %d",
                    np, Points->x[0], Points->y[0], Cats->n_cats);

            gpt->next = (geopoint *) G_malloc(sizeof(geopoint));        /* G_fatal_error */
            if (!gpt->next) {
                return (NULL);
            }

            prev = gpt;
            gpt = gpt->next;
        }

    }
    if (np > 0) {
        prev->next = NULL;
        G_free(gpt);
    }

    Vect_close(&map);

    if (!np) {
        G_warning(_("No points from vector map <%s> fall within current region"),
                  G_fully_qualified_name(grassname, mapset));
        return (NULL);
    }
    else {
        G_message(_("Vector map <%s> loaded (%d points)"),
                  G_fully_qualified_name(grassname, mapset), np);
    }

    *nsites = np;

    return (top);
}