nviz.c

Go to the documentation of this file.

/*!
   \file lib/nviz/nviz.c
 
   \brief Nviz library -- Data management
 
   Based on visualization/nviz/src/
   
   (C) 2008, 2010 by the GRASS Development Team
   This program is free software under the GNU General Public License
   (>=v2). Read the file COPYING that comes with GRASS for details.
 
   \author Updated/modified by Martin Landa <landa.martin gmail.com> (Google SoC 2008/2010)
 */
 
#include <grass/colors.h>
#include <grass/raster.h>
#include <grass/glocale.h>
#include <grass/nviz.h>
 
/*!
   \brief Initialize Nviz data
 
   \param data nviz data
 */
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;
}
 
/*! \brief Free allocated space by nv_data struct
 
  \param data nviz data
*/
void Nviz_destroy_data(nv_data *data)
{
    int i;
    for (i = 0; i < 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; i < data->num_scalebars; i++) {
        G_free(data->scalebar[i]);
        data->scalebar[i] = NULL;
    }
    data->num_scalebars = 0;
    data->scalebar = NULL;
}
 
/*!
   \brief Set background color
 
   \param data nviz data
   \param color color value
 */
void Nviz_set_bgcolor(nv_data * data, int color)
{
    data->bgcolor = color;
 
    return;
}
 
/*!
   \brief Get background color
 
   \param data nviz data
 
   \return color color value
 */
int Nviz_get_bgcolor(nv_data * data)
{
    return data->bgcolor;
}
 
/*!
   \brief Get color value from color string (name or RGB triplet)
 
   \param color_str color string
 
   \return color value
 */
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);
}
 
/*! Add new fringe
 
  \param data nviz data
  \param id surface id
  \param color color
  \param elev fringe elevation
  \param nw,ne,sw,se 1 (turn on) 0 (turn off)
 
  \return pointer to allocated fringe_data structure
  \return NULL on error
*/
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;
}
 
/*! Set fringe
 
  \param data nviz data
  \param id surface id
  \param color color
  \param elev fringe elevation
  \param nw,ne,sw,se 1 (turn on) 0 (turn off)
 
  \return pointer to allocated fringe_data structure
  \return NULL on error
*/
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;
}
/*! Draw fringe
 
   \param data nviz data
 */
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);
    }
}
/*!
   \brief Sets the North Arrow position and return world coords
 
   \param data nviz data
   \param sx,sy screen coordinates
   \param size arrow length
   \param color arrow/text color
 */
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;
}
 
 
/*!
   \brief Draws the North Arrow
 
   \param data nviz data
 */
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;
}
 
/*!
   \brief Deletes the North Arrow
 
   \param data nviz data
 */
void Nviz_delete_arrow(nv_data *data)
{
    data->draw_arrow = 0;
 
    return;
}
 
/*! Add new scalebar
 
  \param data nviz data
  \param bar_id scale bar id
  \param coords real(?) coordinates
  \param size scale bar length
  \param color scalebar/text color
 
  \return pointer to allocated scalebar_data structure
  \return NULL on error
*/
 
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;
 
}
/*!
   \brief Sets the scale bar position and return world coords
 
   \param data nviz data
   \param bar_id scale bar id
   \param sx,sy screen coordinates
   \param size scale bar length
   \param color scalebar/text color
 
   \return pointer to allocated scalebar_data structure
   \return NULL when there's no surface
 */
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++) {
        if (data->scalebar[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;
}
/*!
   \brief Draws the Scale bar
 
   \param data nviz data
 */
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++) {
        if (data->scalebar[i]) {
            struct scalebar_data *s = data->scalebar[i];
 
            gsd_scalebar_v2(s->where, s->size, FontBase, s->color, s->color);
        }
    }
}
 
/*!
   \brief Deletes scale bar
   
   When scalebar is freed, array then contains NULL,
   which must be tested during drawing.
 
   \param data nviz data
 */
void Nviz_delete_scalebar(nv_data *data, int bar_id)
{
    if (bar_id < data->num_scalebars && data->scalebar[bar_id] != NULL) {
        G_free(data->scalebar[bar_id]);
        data->scalebar[bar_id] = NULL;
    }
}