← Back to branch summary

~ubuntu-branches/ubuntu/vivid/grass/vivid-proposed

« back to all changes in this revision

Viewing changes to misc/m.nviz.image/surface.c

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-02-20 23:12:08 UTC
  • mfrom: (8.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20150220231208-1u6qvqm84v430b10
Tags: 7.0.0-1~exp1
* New upstream release.
* Update python-ctypes-ternary.patch to use if/else instead of and/or.
* Drop check4dev patch, rely on upstream check.
* Add build dependency on libpq-dev to grass-dev for libpq-fe.h.
* Drop patches applied upstream, refresh remaining patches.
* Update symlinks for images switched from jpg to png.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/m.nviz.image/surface.c
1
1
/*!
2
 
  \file surface.c
3
 
  
4
 
  \brief Surface subroutines
5
 
  
6
 
  (C) 2008, 2010 by the GRASS Development Team
7
 
  
8
 
  This program is free software under the GNU General Public
9
 
  License (>=v2). Read the file COPYING that comes with GRASS
10
 
  for details.
11
 
  
12
 
  \author Martin Landa <landa.martin gmail.com> (Google SoC 2008/2010)
13
 
*/
 
2
   \file surface.c
 
3
 
 
4
   \brief Surface subroutines
 
5
 
 
6
   (C) 2008, 2010 by the GRASS Development Team
 
7
 
 
8
   This program is free software under the GNU General Public
 
9
   License (>=v2). Read the file COPYING that comes with GRASS
 
10
   for details.
 
11
 
 
12
   \author Martin Landa <landa.martin gmail.com> (Google SoC 2008/2010)
 
13
 */
14
14
 
15
15
#include <stdlib.h>
16
16
#include <string.h>
20
20
#include "local_proto.h"
21
21
 
22
22
/*!
23
 
  \brief Load raster maps/constants and set surface attributes
24
 
  
25
 
  \param params module parameters
26
 
  \param data nviz data
27
 
*/
 
23
   \brief Load raster maps/constants and set surface attributes
 
24
 
 
25
   \param params module parameters
 
26
   \param data nviz data
 
27
 */
28
28
int load_rasters(const struct GParams *params, nv_data * data)
29
29
{
30
 
    char *mapset;
 
30
    const char *mapset;
31
31
    int i;
32
32
    int nelevs, nelev_map, nelev_const, ncolor_map, ncolor_const, nmask_map;
33
33
    int ntransp_map, ntransp_const, nshine_map, nshine_const;
41
41
    nelev_const = opt_get_num_answers(params->elev_const);
42
42
 
43
43
    nelevs = nelev_const + nelev_map;
44
 
 
45
44
    /* topography (required) */
46
45
    for (i = 0; i < nelevs; i++) {
47
46
        /* check maps */
48
47
        if (i < nelev_map && strcmp(params->elev_map->answers[i], "")) {
49
 
            mapset = G_find_cell2(params->elev_map->answers[i], "");
 
48
            mapset = G_find_raster2(params->elev_map->answers[i], "");
50
49
            if (mapset == NULL) {
51
50
                G_fatal_error(_("Raster map <%s> not found"),
52
51
                              params->elev_map->answers[i]);
53
52
            }
54
53
 
55
54
            id = Nviz_new_map_obj(MAP_OBJ_SURF,
56
 
                                  G_fully_qualified_name(params->elev_map->
57
 
                                                         answers[i], mapset),
58
 
                                  0.0, data);
 
55
                                  G_fully_qualified_name(params->
 
56
                                                         elev_map->answers[i],
 
57
                                                         mapset), 0.0, data);
59
58
        }
60
59
        else {
61
 
            if (i-nelev_map < nelev_const && strcmp(params->elev_const->answers[i-nelev_map], "")) {
62
 
                id = Nviz_new_map_obj(MAP_OBJ_SURF,
63
 
                                      NULL,
64
 
                                      atof(params->elev_const->answers[i-nelev_map]),
65
 
                                      data);
 
60
            if (i - nelev_map < nelev_const &&
 
61
                strcmp(params->elev_const->answers[i - nelev_map], "")) {
 
62
                id = Nviz_new_map_obj(MAP_OBJ_SURF, NULL,
 
63
                                      atof(params->elev_const->
 
64
                                           answers[i - nelev_map]), data);
66
65
            }
67
66
            else {
68
67
                G_fatal_error(_("Missing topography attribute for surface %d"),
71
70
        }
72
71
 
73
72
        /* set position */
74
 
    if (opt_get_num_answers(params->surface_pos) != 3 * nelevs){
75
 
        x = atof(params->surface_pos->answers[0]);
76
 
        y = atof(params->surface_pos->answers[1]);
77
 
        z = atof(params->surface_pos->answers[2]);
78
 
    }
79
 
    else {
80
 
        x = atof(params->surface_pos->answers[i*3+0]);
81
 
        y = atof(params->surface_pos->answers[i*3+1]);
82
 
        z = atof(params->surface_pos->answers[i*3+2]);
83
 
    }
 
73
        if (opt_get_num_answers(params->surface_pos) != 3 * nelevs) {
 
74
            x = atof(params->surface_pos->answers[0]);
 
75
            y = atof(params->surface_pos->answers[1]);
 
76
            z = atof(params->surface_pos->answers[2]);
 
77
        }
 
78
        else {
 
79
            x = atof(params->surface_pos->answers[i * 3 + 0]);
 
80
            y = atof(params->surface_pos->answers[i * 3 + 1]);
 
81
            z = atof(params->surface_pos->answers[i * 3 + 2]);
 
82
        }
84
83
 
85
84
        GS_set_trans(id, x, y, z);
86
85
    }
103
102
        /* color */
104
103
        /* check for color map */
105
104
        if (i < ncolor_map && strcmp(params->color_map->answers[i], "")) {
106
 
            mapset = G_find_cell2(params->color_map->answers[i], "");
 
105
            mapset = G_find_raster2(params->color_map->answers[i], "");
107
106
            if (mapset == NULL) {
108
107
                G_fatal_error(_("Raster map <%s> not found"),
109
108
                              params->color_map->answers[i]);
110
109
            }
111
110
 
112
111
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_COLOR, MAP_ATT,
113
 
                          G_fully_qualified_name(params->color_map->
114
 
                                                 answers[i], mapset), -1.0,
115
 
                          data);
 
112
                          G_fully_qualified_name(params->
 
113
                                                 color_map->answers[i],
 
114
                                                 mapset), -1.0, data);
116
115
        }
117
116
        /* check for color value */
118
 
        else if (i-ncolor_map < ncolor_const &&
119
 
                 strcmp(params->color_const->answers[i-ncolor_map], "")) {
 
117
        else if (i - ncolor_map < ncolor_const &&
 
118
                 strcmp(params->color_const->answers[i - ncolor_map], "")) {
120
119
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_COLOR, CONST_ATT, NULL,
121
 
                          Nviz_color_from_str(params->color_const->
122
 
                                              answers[i-ncolor_map]), data);
 
120
                          Nviz_color_from_str(params->
 
121
                                              color_const->answers[i -
 
122
                                                                   ncolor_map]),
 
123
                          data);
123
124
        }
124
125
        else {                  /* use by default elevation map for coloring */
125
 
            if (nelev_map > 0){
126
 
                Nviz_set_attr(id, MAP_OBJ_SURF, ATT_COLOR, MAP_ATT,
127
 
                              G_fully_qualified_name(params->elev_map->answers[i],
128
 
                                                     mapset), -1.0, data);
129
 
                G_verbose_message(_("Color attribute not defined, using default <%s>"),
130
 
                                  G_fully_qualified_name(params->elev_map->
131
 
                                                         answers[i], mapset));
132
 
        }
133
 
        else{
134
 
            G_fatal_error(_("Missing color attribute for surface %d"),
 
126
            if (nelev_map > 0) {
 
127
                Nviz_set_attr(id, MAP_OBJ_SURF, ATT_COLOR, MAP_ATT,
 
128
                              G_fully_qualified_name(params->elev_map->
 
129
                                                     answers[i], mapset),
 
130
                              -1.0, data);
 
131
                G_verbose_message(_("Color attribute not defined, using default <%s>"),
 
132
                                  G_fully_qualified_name(params->
 
133
                                                         elev_map->answers[i],
 
134
                                                         mapset));
 
135
            }
 
136
            else {
 
137
                G_fatal_error(_("Missing color attribute for surface %d"),
135
138
                              i + 1);
136
 
        }
 
139
            }
137
140
        }
138
141
        /* mask */
139
142
        if (i < nmask_map && strcmp(params->mask_map->answers[i], "")) {
145
148
        /* transparency */
146
149
        if (i < ntransp_map && strcmp(params->transp_map->answers[i], "")) {
147
150
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_TRANSP, MAP_ATT,
148
 
                          G_fully_qualified_name(params->transp_map->
149
 
                                                 answers[i], mapset), -1.0,
150
 
                          data);
 
151
                          G_fully_qualified_name(params->
 
152
                                                 transp_map->answers[i],
 
153
                                                 mapset), -1.0, data);
151
154
        }
152
 
        else if (i-ntransp_map < ntransp_const &&
153
 
                 strcmp(params->transp_const->answers[i-ntransp_map], "")) {
 
155
        else if (i - ntransp_map < ntransp_const &&
 
156
                 strcmp(params->transp_const->answers[i - ntransp_map], "")) {
154
157
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_TRANSP, CONST_ATT, NULL,
155
 
                          atof(params->transp_const->answers[i-ntransp_map]), data);
 
158
                          atof(params->transp_const->
 
159
                               answers[i - ntransp_map]), data);
156
160
        }
157
161
 
158
162
        /* shininess */
159
163
        if (i < nshine_map && strcmp(params->shine_map->answers[i], "")) {
160
164
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_SHINE, MAP_ATT,
161
 
                          G_fully_qualified_name(params->shine_map->
162
 
                                                 answers[i], mapset), -1.0,
163
 
                          data);
 
165
                          G_fully_qualified_name(params->
 
166
                                                 shine_map->answers[i],
 
167
                                                 mapset), -1.0, data);
164
168
        }
165
 
        else if (i-nshine_map < nshine_const &&
166
 
                 strcmp(params->shine_const->answers[i-nshine_map], "")) {
 
169
        else if (i - nshine_map < nshine_const &&
 
170
                 strcmp(params->shine_const->answers[i - nshine_map], "")) {
167
171
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_SHINE, CONST_ATT, NULL,
168
 
                          atof(params->shine_const->answers[i-nshine_map]), data);
 
172
                          atof(params->shine_const->answers[i - nshine_map]),
 
173
                          data);
169
174
        }
170
175
 
171
176
        /* emission */
174
179
                          G_fully_qualified_name(params->emit_map->answers[i],
175
180
                                                 mapset), -1.0, data);
176
181
        }
177
 
        else if (i-nemit_map < nemit_const &&
178
 
                 strcmp(params->emit_const->answers[i-nemit_map], "")) {
 
182
        else if (i - nemit_map < nemit_const &&
 
183
                 strcmp(params->emit_const->answers[i - nemit_map], "")) {
179
184
            Nviz_set_attr(id, MAP_OBJ_SURF, ATT_EMIT, CONST_ATT, NULL,
180
 
                          atof(params->emit_const->answers[i-nemit_map]), data);
 
185
                          atof(params->emit_const->answers[i - nemit_map]),
 
186
                          data);
181
187
        }
182
188
 
183
189
        /*
190
196
}
191
197
 
192
198
/*!
193
 
  \brief Set draw mode for loaded surfaces
194
 
  
195
 
  \param params module parameters
196
 
*/
 
199
   \brief Set draw mode for loaded surfaces
 
200
 
 
201
   \param params module parameters
 
202
 */
197
203
void surface_set_draw_mode(const struct GParams *params)
198
204
{
199
205
    int *surf_list, nsurfs;