← 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/vector.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/vector.c
1
1
/*!
2
 
  \file vector.c
3
 
  
4
 
  \brief Vector 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 vector.c
 
3
 
 
4
   \brief Vector subroutines
 
5
 
 
6
   (C) 2008-2013 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>
17
17
 
 
18
#include <grass/vector.h>
 
19
#include <grass/dbmi.h>
18
20
#include <grass/glocale.h>
19
21
 
20
22
#include "local_proto.h"
21
23
 
22
24
static int load_vectors(const struct Option *, const struct Option *,
23
 
                        const struct Option *, const struct Option *, int, nv_data *);
 
25
                        const struct Option *, const struct Option *, int,
 
26
                        nv_data *);
24
27
 
25
28
/*!
26
 
  \brief Load vector maps (lines)
27
 
  
28
 
  \param params module parameters
29
 
  \param data nviz data
30
 
  
31
 
  \return number of loaded vectors
32
 
*/
 
29
   \brief Load vector maps (lines)
 
30
 
 
31
   \param params module parameters
 
32
   \param data nviz data
 
33
 
 
34
   \return number of loaded vectors
 
35
 */
33
36
int load_vlines(const struct GParams *params, nv_data * data)
34
37
{
35
38
    return load_vectors(params->elev_map, params->elev_const,
38
41
}
39
42
 
40
43
/*!
41
 
  \brief Load vector maps (points)
42
 
  
43
 
  \param params module parameters
44
 
  \param data nviz data
45
 
  
46
 
  \return number of loaded vectors
47
 
*/
 
44
   \brief Load vector maps (points)
 
45
 
 
46
   \param params module parameters
 
47
   \param data nviz data
 
48
 
 
49
   \return number of loaded vectors
 
50
 */
48
51
int load_vpoints(const struct GParams *params, nv_data * data)
49
52
{
50
53
    return load_vectors(params->elev_map, params->elev_const,
60
63
    int i, id;
61
64
    int nvects;
62
65
 
63
 
    char *mapset;
64
 
    
 
66
    const char *mapset;
 
67
 
65
68
    double x, y, z;
66
 
    
 
69
 
67
70
    if ((!elev_map->answer || elev_const->answer) && GS_num_surfs() == 0) {     /* load base surface if no loaded */
68
71
        int *surf_list, nsurf;
69
72
 
81
84
            G_fatal_error(_("Vector map <%s> not found"), vect->answers[i]);
82
85
        }
83
86
        id = Nviz_new_map_obj(map_obj_type,
84
 
                              G_fully_qualified_name(vect->answers[i], mapset),
85
 
                              0.0, data);
 
87
                              G_fully_qualified_name(vect->answers[i],
 
88
                                                     mapset), 0.0, data);
86
89
 
87
90
        /* set position */
88
 
        x = atof(position->answers[i*3+0]);
89
 
        y = atof(position->answers[i*3+1]);
90
 
        z = atof(position->answers[i*3+2]);
 
91
        x = atof(position->answers[i * 3 + 0]);
 
92
        y = atof(position->answers[i * 3 + 1]);
 
93
        z = atof(position->answers[i * 3 + 2]);
91
94
 
92
95
        if (map_obj_type == MAP_OBJ_VECT)
93
96
            GV_set_trans(id, x, y, z);
101
104
}
102
105
 
103
106
/*!
104
 
  \brief Set vector lines mode
105
 
  
106
 
  \param params parameters
107
 
  
108
 
  \return 1 on success
109
 
  \return 0 on failure
110
 
*/
 
107
   \brief Set vector lines mode
 
108
 
 
109
   \param params parameters
 
110
 
 
111
   \return 1 on success
 
112
   \return 0 on failure
 
113
 */
111
114
int vlines_set_attrb(const struct GParams *params)
112
115
{
113
 
    int i, color, width, flat, height;
 
116
    int i, layer, color, width, flat, height;
114
117
    int *vect_list, nvects;
 
118
    int have_colors;
 
119
 
 
120
    char *color_column, *width_column;
 
121
    struct Colors colors;
115
122
 
116
123
    vect_list = GV_get_vect_list(&nvects);
117
124
 
118
125
    for (i = 0; i < nvects; i++) {
119
 
        /* mode -- use memory by default */
 
126
        check_map(params, i, TRUE, &layer, NULL);
 
127
 
120
128
        color = Nviz_color_from_str(params->vline_color->answers[i]);
 
129
        color_column = params->vline_color_column->answers ?
 
130
            params->vline_color_column->answers[i] : NULL;
121
131
        width = atoi(params->vline_width->answers[i]);
 
132
        width_column = params->vline_width_column->answers ?
 
133
            params->vline_width_column->answers[i] : NULL;
 
134
 
122
135
        if (strcmp(params->vline_mode->answers[i], "flat") == 0)
123
136
            flat = 1;
124
137
        else
125
138
            flat = 0;
126
 
        if (GV_set_vectmode(vect_list[i], 1, color, width, flat) < 0)
 
139
 
 
140
        /* style (mode -- use memory by default) */
 
141
        if (GV_set_style(vect_list[i], TRUE, color, width, flat) < 0)
127
142
            return 0;
128
143
 
 
144
        /* check for vector color table */
 
145
        have_colors = Vect_read_colors(params->vlines->answers[i], "",
 
146
                                       &colors);
 
147
 
 
148
        if (have_colors || color_column || width_column)
 
149
            if (GV_set_style_thematic(vect_list[i], layer, color_column,
 
150
                                      width_column,
 
151
                                      have_colors ? &colors : NULL) < 0)
 
152
                return 0;
 
153
 
129
154
        /* height */
130
155
        height = atoi(params->vline_height->answers[i]);
131
156
        if (height > 0)
136
161
}
137
162
 
138
163
/*!
139
 
  \brief Set vector points mode
140
 
  
141
 
  \param params parameters
142
 
  
143
 
  \return 1 on success
144
 
  \return 0 on failure
145
 
*/
 
164
   \brief Set vector points style
 
165
 
 
166
   \param params parameters
 
167
 
 
168
   \return 1 on success
 
169
   \return 0 on failure
 
170
 */
146
171
int vpoints_set_attrb(const struct GParams *params)
147
172
{
148
 
    int i;
 
173
    int i, layer, have_colors, with_z;
149
174
    int *site_list, nsites;
150
175
    int marker, color, width;
151
176
    float size;
152
 
    char *marker_str;
 
177
    char *marker_str, *color_column, *size_column, *width_column,
 
178
        *marker_column;
 
179
 
 
180
    struct Colors colors;
153
181
 
154
182
    site_list = GP_get_site_list(&nsites);
155
183
 
156
184
    for (i = 0; i < nsites; i++) {
 
185
        check_map(params, i, FALSE, &layer, &with_z);
 
186
 
157
187
        color = Nviz_color_from_str(params->vpoint_color->answers[i]);
 
188
        color_column = params->vpoint_color_column->answers ?
 
189
            params->vpoint_color_column->answers[i] : NULL;
158
190
        size = atof(params->vpoint_size->answers[i]);
 
191
        size_column = params->vpoint_size_column->answers ?
 
192
            params->vpoint_size_column->answers[i] : NULL;
159
193
        width = atoi(params->vpoint_width->answers[i]);
 
194
        width_column = params->vpoint_width_column->answers ?
 
195
            params->vpoint_width_column->answers[i] : NULL;
160
196
        marker_str = params->vpoint_marker->answers[i];
161
 
 
162
 
        if (strcmp(marker_str, "x") == 0)
163
 
            marker = ST_X;
164
 
        else if (strcmp(marker_str, "sphere") == 0)
165
 
            marker = ST_SPHERE;
166
 
        else if (strcmp(marker_str, "diamond") == 0)
167
 
            marker = ST_DIAMOND;
168
 
        else if (strcmp(marker_str, "cube") == 0)
169
 
            marker = ST_CUBE;
170
 
        else if (strcmp(marker_str, "box") == 0)
171
 
            marker = ST_BOX;
172
 
        else if (strcmp(marker_str, "gyro") == 0)
173
 
            marker = ST_GYRO;
174
 
        else if (strcmp(marker_str, "aster") == 0)
175
 
            marker = ST_ASTER;
176
 
        else if (strcmp(marker_str, "histogram") == 0)
177
 
            marker = ST_HISTOGRAM;
178
 
        else
179
 
            G_fatal_error(_("Unknown icon marker"));
180
 
        
181
 
        GP_set_sitemode(site_list[i], ST_ATT_NONE,
182
 
                        color, width, size, marker);
183
 
        
184
 
        /* GP_set_style(site_list[i], color, width, size, marker); */
 
197
        marker_column = params->vpoint_marker_column->answers ?
 
198
            params->vpoint_marker_column->answers[i] : NULL;
 
199
        marker = GP_str_to_marker(marker_str);
 
200
 
 
201
        if (with_z) {
 
202
            if (strcmp(params->vpoint_mode->answers[i], "surface") == 0)
 
203
                GP_set_zmode(site_list[i], FALSE);
 
204
            else
 
205
                GP_set_zmode(site_list[i], TRUE);
 
206
        }
 
207
 
 
208
        if (GP_set_style(site_list[i], color, width, size, marker) < 0)
 
209
            return 0;
 
210
 
 
211
        /* check for vector color table */
 
212
        have_colors = Vect_read_colors(params->vpoints->answers[i], "",
 
213
                                       &colors);
 
214
 
 
215
        if (have_colors || color_column || width_column ||
 
216
            size_column || marker_column) {
 
217
            if (GP_set_style_thematic(site_list[i], layer, color_column,
 
218
                                      width_column, size_column,
 
219
                                      marker_column,
 
220
                                      have_colors ? &colors : NULL) < 0)
 
221
                return 0;
 
222
        }
185
223
    }
186
224
 
187
225
    return 1;
188
226
}
 
227
 
 
228
/*!
 
229
   \brief Check vector map
 
230
 
 
231
   \param params parameters
 
232
   \param index answers array index
 
233
   \param vlines TRUE for lines otherwise points
 
234
   \param[out] field number
 
235
   \param[out] WITH_Z for 3D maps
 
236
 
 
237
   \return 0 on success otherwise 1
 
238
 */
 
239
int check_map(const struct GParams *params, int index, int vlines,
 
240
              int *field, int *with_z)
 
241
{
 
242
    int type;
 
243
    struct Map_info Map;
 
244
    const char *map, *layer, *color, *size, *width, *marker;
 
245
    struct field_info *Fi;
 
246
 
 
247
    dbDriver *driver;
 
248
    dbColumn *column;
 
249
 
 
250
    Fi = NULL;
 
251
    driver = NULL;
 
252
 
 
253
    if (vlines) {
 
254
        map = params->vlines->answers[index];
 
255
        layer = params->vline_layer->answers[index];
 
256
        color = params->vline_color_column->answers ?
 
257
            params->vline_color_column->answers[index] : NULL;
 
258
        size = NULL;
 
259
        width = params->vline_width_column->answers ?
 
260
            params->vline_width_column->answers[index] : NULL;
 
261
        marker = NULL;
 
262
    }
 
263
    else {
 
264
        map = params->vpoints->answers[index];
 
265
        layer = params->vpoint_layer->answers[index];
 
266
        color = params->vpoint_color_column->answers ?
 
267
            params->vpoint_color_column->answers[index] : NULL;
 
268
        size = params->vpoint_size_column->answers ?
 
269
            params->vpoint_size_column->answers[index] : NULL;
 
270
        width = params->vpoint_width_column->answers ?
 
271
            params->vpoint_width_column->answers[index] : NULL;
 
272
        marker = params->vpoint_marker_column->answers ?
 
273
            params->vpoint_marker_column->answers[index] : NULL;
 
274
    }
 
275
 
 
276
    if (!map)
 
277
        return 1;
 
278
 
 
279
    if (1 > Vect_open_old(&Map, map, ""))
 
280
        G_fatal_error(_("Unable to open vector map <%s>"), map);
 
281
    Vect_set_error_handler_io(&Map, NULL);
 
282
 
 
283
    if (with_z)
 
284
        *with_z = Vect_is_3d(&Map);
 
285
 
 
286
    *field = -1;
 
287
    Fi = Vect_get_field2(&Map, layer);
 
288
    if (Fi) {
 
289
        *field = Fi->number;
 
290
 
 
291
        driver = db_start_driver_open_database(Fi->driver, Fi->database);
 
292
        if (!driver)
 
293
            G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
 
294
                          Fi->database, Fi->driver);
 
295
        db_set_error_handler_driver(driver);
 
296
 
 
297
        if (color) {
 
298
            db_get_column(driver, Fi->table, color, &column);
 
299
            if (!column)
 
300
                G_fatal_error(_("Column <%s> in table <%s> not found"),
 
301
                              color, Fi->table);
 
302
 
 
303
            if (db_column_Ctype(driver, Fi->table, color) != DB_C_TYPE_STRING)
 
304
                G_fatal_error(_("Data type of color column must be character"));
 
305
        }
 
306
        if (size) {
 
307
            db_get_column(driver, Fi->table, size, &column);
 
308
            if (!column)
 
309
                G_fatal_error(_("Column <%s> in table <%s> not found"),
 
310
                              size, Fi->table);
 
311
 
 
312
            type = db_column_Ctype(driver, Fi->table, size);
 
313
            if (type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE)
 
314
                G_fatal_error(_("Data type of size column must be numeric"));
 
315
        }
 
316
        if (width) {
 
317
            db_get_column(driver, Fi->table, width, &column);
 
318
            if (!column)
 
319
                G_fatal_error(_("Column <%s> in table <%s> not found"),
 
320
                              width, Fi->table);
 
321
 
 
322
            type = db_column_Ctype(driver, Fi->table, width);
 
323
            if (type != DB_C_TYPE_INT && type != DB_C_TYPE_DOUBLE)
 
324
                G_fatal_error(_("Data type of width column must be numeric"));
 
325
        }
 
326
        if (marker) {
 
327
            db_get_column(driver, Fi->table, marker, &column);
 
328
            if (!column)
 
329
                G_fatal_error(_("Column <%s> in table <%s> not found"),
 
330
                              marker, Fi->table);
 
331
 
 
332
            type = db_column_Ctype(driver, Fi->table, marker);
 
333
            if (db_column_Ctype(driver, Fi->table, marker) !=
 
334
                DB_C_TYPE_STRING)
 
335
                G_fatal_error(_("Data type of marker column must be character"));
 
336
        }
 
337
 
 
338
        db_close_database_shutdown_driver(driver);
 
339
    }
 
340
 
 
341
    Vect_close(&Map);
 
342
 
 
343
    return 0;
 
344
}