nviz.c

Go to the documentation of this file.

#include <grass/glocale.h>
#include <grass/nviz.h>

void Nviz_init_data(nv_data * data)
{
    unsigned int i;

    /* data range */
    data->zrange = 0;
    data->xyrange = 0;

    /* clip planes, turn off by default */
    data->num_cplanes = 0;
    data->cur_cplane = 0;
    for (i = 0; i < MAX_CPLANES; i++) {
        Nviz_new_cplane(data, i);
        Nviz_off_cplane(data, i);
    }

    /* lights */
    GS_set_light_reset(1);
    
    for (i = 0; i < MAX_LIGHTS - 1; i++) {
        Nviz_new_light(data);
    }

    /* fringe */
    data->num_fringes = 0;
    data->fringe = NULL;

    /* north arrow */
    data->draw_arrow = 0;
    data->arrow = NULL;

    /* scale bar*/
    data->num_scalebars = 0;
    data->scalebar = NULL;

    return;
}

void Nviz_destroy_data(nv_data *data)
{
    int i;
    for (i = 0; data->num_fringes; i++) {
        G_free(data->fringe[i]);
        data->fringe[i] = NULL;
    }
    data->num_fringes = 0;
    data->fringe = NULL;
    
    if (data->arrow) {
        G_free(data->arrow);
        data->arrow = NULL;
        data->draw_arrow = 0;
    }

    for (i = 0; data->num_scalebars; i++) {
        G_free(data->scalebar[i]);
        data->scalebar[i] = NULL;
    }
    data->num_scalebars = 0;
    data->scalebar = NULL;
}

void Nviz_set_bgcolor(nv_data * data, int color)
{
    data->bgcolor = color;

    return;
}

int Nviz_get_bgcolor(nv_data * data)
{
    return data->bgcolor;
}

int Nviz_color_from_str(const char *color_str)
{
    int red, grn, blu;

    if (G_str_to_color(color_str, &red, &grn, &blu) != 1) {
        G_warning(_("Invalid color (%s), using \"white\" as default"),
                  color_str);
        red = grn = blu = 255;
    }

    return (red & RED_MASK) + ((int)((grn) << 8) & GRN_MASK) +
        ((int)((blu) << 16) & BLU_MASK);
}

struct fringe_data *Nviz_new_fringe(nv_data *data,
                                    int id, unsigned long color,
                                    double elev, int nw, int ne, int sw, int se)
{
    int num;
    int *surf;
    struct fringe_data *f;

    if (!GS_surf_exists(id)) {
        /* select first surface from the list */
        surf = GS_get_surf_list(&num);
        if (num < 1)
            return NULL;
        id = surf[0];
        G_free(surf);
    }
     

    f = (struct fringe_data *) G_malloc(sizeof(struct fringe_data));
    f->id = id;
    f->color = color;
    f->elev = elev;
    f->where[0] = nw;
    f->where[1] = ne;
    f->where[2] = sw;
    f->where[3] = se;

    data->fringe = (struct fringe_data **) G_realloc(data->fringe, data->num_fringes + 1 * sizeof(struct fringe_data *));
    data->fringe[data->num_fringes++] = f;
    
    return f;
}

struct fringe_data *Nviz_set_fringe(nv_data *data,
                                    int id, unsigned long color,
                                    double elev, int nw, int ne, int sw, int se)
{
    int i, num;
    int *surf;
    struct fringe_data *f;

    if (!GS_surf_exists(id)) {
        /* select first surface from the list */
        surf = GS_get_surf_list(&num);
        if (num < 1)
            return NULL;
        id = surf[0];
        G_free(surf);
    }
    
    for (i = 0; i < data->num_fringes; i++) {
        f = data->fringe[i];
        if (f->id == id) {
            f->color = color;
            f->elev  = elev;
            f->where[0] = nw;
            f->where[1] = ne;
            f->where[2] = sw;
            f->where[3] = se;
            
            return f;
        }
    }

    f = Nviz_new_fringe(data,
                        id, color,
                        elev, nw, ne, sw, se);
    
    return f;
}
void Nviz_draw_fringe(nv_data *data)
{
    int i;

    for (i = 0; i < data->num_fringes; i++) {
        struct fringe_data *f = data->fringe[i];

        GS_draw_fringe(f->id, f->color, f->elev, f->where);
    }
}
int Nviz_set_arrow(nv_data *data,
                   int sx, int sy, float size,
                   unsigned int color)
{
    int id, pt[2];
    int *surf_list, num_surfs;
    float coords[3];
    struct arrow_data *arw;

    if (GS_num_surfs() > 0) {
        surf_list = GS_get_surf_list(&num_surfs);
        id = surf_list[0];
        G_free(surf_list);

        pt[0] = sx;
        pt[1] = sy;

        GS_set_Narrow(pt, id, coords);

        if (data->arrow) {
            data->arrow->color = color;
            data->arrow->size  = size;
            data->arrow->where[0]  = coords[0];
            data->arrow->where[1]  = coords[1];
            data->arrow->where[2]  = coords[2];
        }    
        else {
            arw = (struct arrow_data *) G_malloc(sizeof(struct arrow_data));
            arw->color = color;
            arw->size  = size;
            arw->where[0]  = coords[0];
            arw->where[1]  = coords[1];
            arw->where[2]  = coords[2];

            data->arrow = arw;
        }
        return 1;
    }
    return 0;
}


int Nviz_draw_arrow(nv_data *data)
{

    struct arrow_data *arw = data->arrow;
    GLuint FontBase = 0; /* don't know how to get fontbase*/

    data->draw_arrow = 1;
    gsd_north_arrow(arw->where, arw->size, FontBase, arw->color, arw->color);

    return 1;
}

void Nviz_delete_arrow(nv_data *data)
{
    data->draw_arrow = 0;

    return;
}

struct scalebar_data *Nviz_new_scalebar(nv_data *data,
                      int bar_id, float *coords, float size,
                      unsigned int color)
{
    struct scalebar_data *s;
     

    s = (struct scalebar_data *) G_malloc(sizeof(struct scalebar_data));
    s->id = bar_id;
    s->color = color;
    s->size = size;
    s->where[0] = coords[0];
    s->where[1] = coords[1];
    s->where[2] = coords[2];

    data->scalebar = (struct scalebar_data **) G_realloc(data->scalebar,
                      data->num_scalebars + 1 * sizeof(struct scalebar_data *));
    data->scalebar[data->num_scalebars++] = s;

    return s;

}
struct scalebar_data *Nviz_set_scalebar(nv_data *data, int bar_id,
                      int sx, int sy, float size,
                      unsigned int color)
{
    int i, id, pt[2];
    int *surf_list, num_surfs;
    float coords[3];
    struct scalebar_data *s;

    if (GS_num_surfs() > 0) {
        surf_list = GS_get_surf_list(&num_surfs);
        id = surf_list[0];
        G_free(surf_list);

        pt[0] = sx;
        pt[1] = sy;

        GS_set_Narrow(pt, id, coords); /* the same like arrow */

        for (i = 0; i < data->num_scalebars; i++) {
            s = data->scalebar[i];
            if (s->id == bar_id) {
                s->color = color;
                s->size = size;
                s->where[0] = coords[0];
                s->where[1] = coords[1];
                s->where[2] = coords[2];

                return s;
            }
        }
        
        s = Nviz_new_scalebar(data, bar_id, coords, size, color);

        return s;
    }
    return NULL;
}
void Nviz_draw_scalebar(nv_data *data)
{
    int i;

    GLuint FontBase = 0; /* don't know how to get fontbase*/

    for (i = 0; i < data->num_scalebars; i++) {
        struct scalebar_data *s = data->scalebar[i];

        gsd_scalebar_v2(s->where, s->size, FontBase, s->color, s->color);
    }
}

void Nviz_delete_scalebar(nv_data *data, int bar_id)
{
    if (bar_id < data->num_scalebars) {
        G_free(data->scalebar[bar_id]);
        data->scalebar[bar_id] = NULL;
        data->num_scalebars--;
    }
}