GRASS GIS 8 Programmer's Manual  8.5.0dev(2025)-b35369f6b7
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
gvld.c
Go to the documentation of this file.
1 /*!
2  \file lib/ogsf/gvld.c
3 
4  \brief OGSF library - loading and manipulating volumes (lower level
5  functions)
6 
7  GRASS OpenGL gsurf OGSF Library
8 
9  (C) 1999-2008 by the GRASS Development Team
10 
11  This program is free software under the
12  GNU General Public License (>=v2).
13  Read the file COPYING that comes with GRASS
14  for details.
15 
16  \author Tomas Paudits (February 2004)
17  \author Doxygenized by Martin Landa <landa.martin gmail.com> (May 2008)
18  */
19 
20 #include <math.h>
21 
22 #include <grass/gis.h>
23 #include <grass/ogsf.h>
24 
25 #include "mc33_table.h"
26 
27 /* useful macros */
28 #define READ() gvl_read_char(pos[i]++, gvl->isosurf[i]->data)
29 
30 /*!
31  \brief Draw volume set (slices and isosurfaces)
32 
33  \param gvl pointer to geovol struct
34 
35  \return -1 on failure
36  \return 1 on success
37  */
38 int gvld_vol(geovol *gvl)
39 {
40  G_debug(5, "gvld_vol(): id=%d", gvl->gvol_id);
41 
42  /* SLICES */
43  /* calculate slices data, if slices changed */
44  if (0 > gvl_slices_calc(gvl))
45  return (-1);
46  /* draw slices */
47  if (0 > gvld_slices(gvl))
48  return (-1);
49 
50  /* ISOSURFACES */
51  /* calculate isosurfaces data, if isosurfaces changed */
52  if (0 > gvl_isosurf_calc(gvl))
53  return (-1);
54  /* draw isosurfaces */
55  if (0 > gvld_isosurf(gvl))
56  return (-1);
57 
58  return (1);
59 }
60 
61 /*!
62  \brief Draw volume in wire mode (bounding box)
63 
64  \param gvl pointer to geovol struct
65 
66  \return -1 on failure
67  \return 1 on success
68  */
70 {
71  G_debug(5, "gvld_wire_vol(): id=%d", gvl->gvol_id);
72 
73  gvld_wind3_box(gvl);
74 
75  if (0 > gvld_wire_slices(gvl))
76  return (-1);
77 
78  if (0 > gvld_wire_isosurf(gvl))
79  return (-1);
80 
81  return (1);
82 }
83 
84 /*!
85  \brief Draw volume isosurfaces
86 
87  \param gvl pointer to geovol struct
88 
89  \return -1 on failure
90  \return 1 on success
91  */
93 {
94  float tx, ty, tz;
95  int cols, rows, depths;
96  int x, y, z, i, iv;
97  float xc, yc, zc;
98  float xres, yres, zres;
99  unsigned r, g, b;
100 
101  int j, p, num, c_ndx, crnt_ev;
102  float n[3], pt[4];
103 
104  int n_i = gvl->n_isosurfs;
105 
106  int *check_color, *check_transp, *check_material, *check_emis, *check_shin;
107  float *kem, *ksh, pkem, pksh;
108  unsigned int *ktrans, *curcolor;
109  int pktransp = 0;
110  int ret = 0;
111 
112  int *pos, *nz, *e_dl, tmp_pos, edge_pos[13];
113 
114  GLdouble modelMatrix[16], projMatrix[16];
115  GLint viewport[4];
116  GLint window[4];
117 
118  geovol_isosurf *isosurf;
119 
120  /* Allocate memory for arrays */
121 
122  check_color = G_malloc(n_i * sizeof(int));
123  check_transp = G_malloc(n_i * sizeof(int));
124  check_material = G_malloc(n_i * sizeof(int));
125  check_emis = G_malloc(n_i * sizeof(int));
126  check_shin = G_malloc(n_i * sizeof(int));
127 
128  kem = G_malloc(n_i * sizeof(float));
129  ksh = G_malloc(n_i * sizeof(float));
130 
131  ktrans = G_malloc(n_i * sizeof(unsigned int));
132  curcolor = G_malloc(n_i * sizeof(unsigned int));
133 
134  pos = G_malloc(n_i * sizeof(int));
135  nz = G_malloc(n_i * sizeof(int));
136  e_dl = G_malloc(n_i * sizeof(int));
137 
138  G_debug(5, "gvld_isosurf():");
139  for (i = 0; i < gvl->n_isosurfs; i++) {
140  G_debug(5, " start : gvl: %s isosurf : %d\n",
141  gvl_file_get_name(gvl->hfile), i);
142  }
143 
144  /* shade */
146 
147  /* scaling */
148  GS_get_scale(&tx, &ty, &tz, 1);
149 
150  /* set number of cols, rows, dephs */
151  cols = gvl->cols / gvl->isosurf_x_mod;
152  rows = gvl->rows / gvl->isosurf_y_mod;
153  depths = gvl->depths / gvl->isosurf_z_mod;
154 
155  /* set x,y,z resolution */
156  xres =
157  /*((float) gvl->cols) / ((float) cols) */ gvl->isosurf_x_mod *
158  gvl->xres;
159  yres =
160  /*((float) gvl->rows) / ((float) rows) */ gvl->isosurf_y_mod *
161  gvl->yres;
162  zres =
163  /*((float) gvl->depths) / ((float) depths) */ gvl->isosurf_z_mod *
164  gvl->zres;
165 
166  /* get viewport */
167  gsd_getwindow(window, viewport, modelMatrix, projMatrix);
168 
169  /* adjust window */
170  window[0] += (int)(yres * 2);
171  window[1] -= (int)(yres * 2);
172  window[2] -= (int)(xres * 2);
173  window[3] += (int)(xres * 2);
174 
176  gsd_pushmatrix();
177  gsd_do_scale(1);
178  gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
179 
180  pkem = 1.0;
181  pksh = 1.0;
182 
183  /* set default attribute values for isosurfaces */
184  for (i = 0; i < gvl->n_isosurfs; i++) {
185  isosurf = gvl->isosurf[i];
186 
187  /* init isosurf one cube edge datalength */
188  e_dl[i] = 4;
189 
190  /* transparency */
191  check_transp[i] = 0;
192  ktrans[i] = (255U << 24);
193  if (CONST_ATT == isosurf->att[ATT_TRANSP].att_src &&
194  isosurf->att[ATT_TRANSP].constant != 0.0) {
195  ktrans[i] = (255 - (int)isosurf->att[ATT_TRANSP].constant) << 24;
196  }
197  else if (MAP_ATT == isosurf->att[ATT_TRANSP].att_src) {
198  check_transp[i] = 1;
199  e_dl[i]++;
200  }
201 
202  /* emis */
203  check_emis[i] = 0;
204  kem[i] = 0.0;
205  if (CONST_ATT == isosurf->att[ATT_EMIT].att_src) {
206  kem[i] = isosurf->att[ATT_EMIT].constant / 255.;
207  }
208  else if (MAP_ATT == isosurf->att[ATT_EMIT].att_src) {
209  check_emis[i] = 1;
210  e_dl[i]++;
211  }
212 
213  /* shin */
214  check_shin[i] = 0;
215  ksh[i] = 0.0;
216  if (CONST_ATT == isosurf->att[ATT_SHINE].att_src) {
217  ksh[i] = isosurf->att[ATT_SHINE].constant / 255.;
218  }
219  else if (MAP_ATT == isosurf->att[ATT_SHINE].att_src) {
220  check_shin[i] = 1;
221  e_dl[i]++;
222  }
223 
224  /* color */
225  check_color[i] = 0;
226  curcolor[i] = 0.0;
227  if (CONST_ATT == isosurf->att[ATT_COLOR].att_src) {
228  curcolor[i] = (int)isosurf->att[ATT_COLOR].constant;
229  }
230  else if (MAP_ATT == isosurf->att[ATT_COLOR].att_src) {
231  check_color[i] = 1;
232  e_dl[i] += 3;
233  }
234 
235  /* check material */
236  check_material[i] =
237  (check_shin[i] || check_emis[i] || (kem[i] && check_color[i]));
238 
239  /* set position in data */
240  pos[i] = 0;
241  nz[i] = 0;
242  }
243 
244  G_debug(5, " initialize OK");
245 
246  for (z = 0; z < depths - 1; z++) {
247  zc = z * zres;
248 
249  if (GS_check_cancel()) {
250  for (i = 0; i < gvl->n_isosurfs; i++) {
251  G_debug(5, " break : isosurf : %d datalength : %d B\n", i,
252  pos[i]);
253  }
254 
255  gsd_set_material(1, 1, 0., 0., 0x0);
256  gsd_popmatrix();
257  gsd_blend(0);
258  gsd_zwritemask(0xffffffff);
259  ret = -1;
260  goto cleanup_exit;
261  }
262 
263  for (y = 0; y < rows - 1; y++) {
264  yc = ((rows - 1) * yres) - (y * yres);
265 
266  for (x = 0; x < cols - 1; x++) {
267  xc = x * xres;
268 
269  for (i = 0; i < gvl->n_isosurfs; i++) {
270 
271  /* read cube index */
272  if (nz[i] != 0) {
273  nz[i]--;
274  continue;
275  }
276  else {
277  c_ndx = READ();
278  if (c_ndx == 0) {
279  nz[i] = READ() - 1;
280  continue;
281  }
282  else {
283  c_ndx = (c_ndx - 1) * 256 + READ();
284  }
285  }
286 
287  /* save position */
288  tmp_pos = pos[i];
289 
290  /* set position for each cube edge data */
291  iv = 0;
292  for (j = 0; j < cell_table[c_ndx].nedges; j++) {
293  if (cell_table[c_ndx].edges[j] == 12)
294  iv = 1;
295 
296  edge_pos[cell_table[c_ndx].edges[j]] =
297  pos[i] + j * e_dl[i];
298  }
299 
300  /* enable/disable blending and depth buffer writing */
301  if (check_transp[i] || (ktrans[i] >> 24) < 255) {
302  if (!pktransp) {
303  gsd_blend(1);
304  gsd_zwritemask(0);
305  }
306  }
307  else if (pktransp) {
308  gsd_blend(0);
309  gsd_zwritemask(0xffffffff);
310  pktransp = 0;
311  }
312 
313  /* draw cube polygons */
314  for (p = 0, num = 0; num < cell_table[c_ndx].npolys;
315  num++) {
316  gsd_bgnpolygon();
317 
318  for (j = 0; j < 3; j++) {
319  crnt_ev = cell_table[c_ndx].polys[p];
320  /* set position in data to current edge data */
321  pos[i] = edge_pos[crnt_ev];
322 
323  /* triangle vertex */
324  if (crnt_ev == 12) {
325  pt[X] = xc + (READ() / 255. * xres);
326  pt[Y] = yc + (-(READ() / 255. * yres));
327  pt[Z] = zc + (READ() / 255. * zres);
328  }
329  else {
330  pt[edge_vert_pos[crnt_ev][0]] = READ() / 255.;
331  pt[edge_vert_pos[crnt_ev][1]] =
332  edge_vert_pos[crnt_ev][2];
333  pt[edge_vert_pos[crnt_ev][3]] =
334  edge_vert_pos[crnt_ev][4];
335 
336  pt[X] = xc + (pt[X] * xres);
337  pt[Y] = yc + (-(pt[Y] * yres));
338  pt[Z] = zc + (pt[Z] * zres);
339  }
340 
341  n[X] = (READ() / 127. - 1.) / xres;
342  n[Y] = (-(READ() / 127. - 1.)) / yres;
343  n[Z] = (READ() / 127. - 1.) / zres;
344 
345  if (gvl->isosurf[i]->inout_mode) {
346  n[X] *= -1;
347  n[Y] *= -1;
348  n[Z] *= -1;
349  }
350 
351  if (check_color[i]) {
352  r = READ();
353  g = READ();
354  b = READ();
355  curcolor[i] = (r & 0xff) | ((g & 0xff) << 8) |
356  ((b & 0xff) << 16);
357  }
358 
359  if (check_transp[i])
360  ktrans[i] = READ() << 24;
361  ;
362 
363  if (check_shin[i])
364  ksh[i] = ((float)READ()) / 255.;
365 
366  if (check_emis[i])
367  kem[i] = ((float)READ()) / 255.;
368 
369  if (pksh != ksh[i] || pkem != kem[i] ||
370  (kem[i] && check_color[i])) {
371  pksh = ksh[i];
372  pkem = kem[i];
373  gsd_set_material(1, 1, ksh[i], kem[i],
374  curcolor[i]);
375  }
376 
377  gsd_litvert_func(n, ktrans[i] | curcolor[i], pt);
378  p++;
379  }
380 
381  gsd_endpolygon();
382  }
383 
384  /* set position to next cube */
385  pos[i] = tmp_pos + cell_table[c_ndx].nedges * e_dl[i] +
386  (iv ? 2 : 0);
387  }
388  }
389  }
390  }
391 
392  for (i = 0; i < gvl->n_isosurfs; i++) {
393  G_debug(5, " end : isosurf : %d datalength : %d B\n", i, pos[i]);
394  }
395 
396  gsd_set_material(1, 1, 0., 0., 0x0);
397  gsd_popmatrix();
398  gsd_blend(0);
399  gsd_zwritemask(0xffffffff);
400 cleanup_exit:
401  G_free(e_dl);
402  G_free(nz);
403  G_free(pos);
404  G_free(curcolor);
405  G_free(ktrans);
406  G_free(ksh);
407  G_free(kem);
408  G_free(check_shin);
409  G_free(check_emis);
410  G_free(check_material);
411  G_free(check_transp);
412  G_free(check_color);
413  return ret;
414 }
415 
416 /*!
417  \brief Draw volume isosurface in draw mode
418 
419  \param gvl pointer to geovol struct [unused]
420 
421  \return 0
422  */
424 {
425  return (0);
426 }
427 
428 /************************************************************************/
429 /* SLICES */
430 
431 /************************************************************************/
432 
433 #define DISTANCE_2(x1, y1, x2, y2) \
434  sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
435 
436 /*!
437  \brief Draw slices
438 
439  \param gvl pointer to geovol struct
440 
441  \return 0
442  */
444 {
445  float tx, ty, tz;
446  int i;
447 
448  GLdouble modelMatrix[16], projMatrix[16];
449  GLint viewport[4];
450  GLint window[4];
451 
452  G_debug(5, "gvld_slices");
453 
454  /* shade */
456 
457  /* scaling */
458  GS_get_scale(&tx, &ty, &tz, 1);
459 
460  /* get viewport */
461  gsd_getwindow(window, viewport, modelMatrix, projMatrix);
462 
464  gsd_pushmatrix();
465  gsd_do_scale(1);
466  gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
467 
468  for (i = 0; i < gvl->n_slices; i++) {
469  gsd_blend(0);
470  gsd_zwritemask(0xffffffff);
471 
472  if (gvl->slice[i]->transp == 0)
473  gvld_slice(gvl, i);
474  }
475 
476  for (i = 0; i < gvl->n_slices; i++) {
477  gsd_blend(1);
478  gsd_zwritemask(0x0);
479 
480  if (gvl->slice[i]->transp > 0)
481  gvld_slice(gvl, i);
482  }
483 
484  gsd_set_material(1, 1, 0., 0., 0x0);
485  gsd_popmatrix();
486  gsd_blend(0);
487  gsd_zwritemask(0xffffffff);
488 
489  return (0);
490 }
491 
492 /*!
493  \brief Draw slice
494 
495  \param gvl pointer to geovol struct
496  \param ndx
497 
498  \return 1
499  */
500 int gvld_slice(geovol *gvl, int ndx)
501 {
502  geovol_slice *slice;
503 
504  int color, offset, transp;
505  float n[3], pt[4];
506  float x, nextx, y, nexty, z, stepx, stepy, stepz;
507  int cols, rows, c, r;
508  float f_cols, f_rows, distxy, distz, modx, mody, modz, modxy;
509  int ptX, ptY, ptZ;
510  double resx, resy, resz;
511 
512  /* current slice */
513  slice = gvl->slice[ndx];
514 
515  /* distance between slice def. pts */
516  distxy = DISTANCE_2(slice->x2, slice->y2, slice->x1, slice->y1);
517  distz = fabsf(slice->z2 - slice->z1);
518 
519  /* distance between slice def pts is zero - zero slice */
520  if (distxy == 0. || distz == 0.) {
521  return (1);
522  }
523 
524  /* set slice mod, resolution and set correct coords */
525  if (slice->dir == X) {
526  modx = gvl->slice_y_mod;
527  mody = gvl->slice_z_mod;
528  modz = gvl->slice_x_mod;
529  resx = gvl->yres;
530  resy = gvl->zres;
531  resz = gvl->xres;
532  ptX = Y;
533  ptY = Z;
534  ptZ = X;
535  }
536  else if (slice->dir == Y) {
537  modx = gvl->slice_x_mod;
538  mody = gvl->slice_z_mod;
539  modz = gvl->slice_y_mod;
540  resx = gvl->xres;
541  resy = gvl->zres;
542  resz = gvl->yres;
543  ptX = X;
544  ptY = Z;
545  ptZ = Y;
546  }
547  else {
548  modx = gvl->slice_x_mod;
549  mody = gvl->slice_y_mod;
550  modz = gvl->slice_z_mod;
551  resx = gvl->xres;
552  resy = gvl->yres;
553  resz = gvl->zres;
554  ptX = X;
555  ptY = Y;
556  ptZ = Z;
557  }
558 
559  /* x,y mod */
560  modxy = DISTANCE_2((slice->x2 - slice->x1) / distxy * modx,
561  (slice->y2 - slice->y1) / distxy * mody, 0., 0.);
562 
563  /* cols/rows of slice */
564  f_cols = distxy / modxy;
565  cols = f_cols > (int)f_cols ? (int)f_cols + 1 : (int)f_cols;
566 
567  f_rows = distz / modz;
568  rows = f_rows > (int)f_rows ? (int)f_rows + 1 : (int)f_rows;
569 
570  /* step in x,y for each row of slice */
571  stepx = (slice->x2 - slice->x1) / f_cols;
572  stepy = (slice->y2 - slice->y1) / f_cols;
573  stepz = (slice->z2 - slice->z1) / f_rows;
574 
575  /* set x,y initially to first slice pt */
576  x = (slice->x1);
577  y = (slice->y1);
578 
579  /* set next draw pt */
580  if (f_cols < 1.) {
581  nextx = x + stepx * f_cols;
582  nexty = y + stepy * f_cols;
583  }
584  else {
585  nextx = x + stepx;
586  nexty = y + stepy;
587  }
588 
589  /* set transparency */
590  if (slice->transp > 0) {
591  transp = (255 - slice->transp) << 24;
592  }
593  else {
594  transp = 0x0;
595  }
596 
597  /* loop in slice cols */
598  for (c = 0; c < cols; c++) {
599 
600  /* set z to slice z1 pt */
601  z = slice->z1;
602 
603  /* begin draw one row - triangle strip */
604  gsd_bgntmesh();
605 
606  /* loop in slice rows */
607  for (r = 0; r < rows + 1; r++) {
608  /* offset to data - 1. column */
609  offset = (c + 1) * (rows + 1) * 3 + r * 3;
610 
611  /* get color from slice data */
612  color = (slice->data[offset] & 0xff) |
613  ((slice->data[offset + 1] & 0xff) << 8) |
614  ((slice->data[offset + 2] & 0xff) << 16);
615 
616  /* triangle vertices */
617  pt[ptX] = nextx * resx;
618  pt[ptY] = nexty * resy;
619  pt[ptZ] = z * resz;
620 
621  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
622  gsd_litvert_func(n, (unsigned int)transp | color, pt);
623 
624  /* offset to data - 2. column */
625  offset = c * (rows + 1) * 3 + r * 3;
626 
627  /* get color from slice data */
628  color = (slice->data[offset] & 0xff) |
629  ((slice->data[offset + 1] & 0xff) << 8) |
630  ((slice->data[offset + 2] & 0xff) << 16);
631 
632  /* set triangle vertices */
633  pt[ptX] = x * resx;
634  pt[ptY] = y * resy;
635  pt[ptZ] = z * resz;
636 
637  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
638  gsd_litvert_func(n, (unsigned int)transp | color, pt);
639 
640  if (r + 1 > f_rows) {
641  z += stepz * (f_rows - (float)r);
642  }
643  else {
644  z += stepz;
645  }
646  }
647 
648  gsd_endtmesh();
649 
650  /* step */
651  if (c + 2 > f_cols) {
652  x += stepx;
653  nextx += stepx * (f_cols - (float)(c + 1));
654  y += stepy;
655  nexty += stepy * (f_cols - (float)(c + 1));
656  }
657  else {
658  x += stepx;
659  nextx += stepx;
660  y += stepy;
661  nexty += stepy;
662  }
663  }
664 
665  gsd_blend(0);
666  gsd_zwritemask(0xffffffff);
667 
668  return (1);
669 }
670 
671 /*!
672  \brief Draw wire slices
673 
674  \param gvl pointer to geovol struct
675 
676  \return 0
677  */
679 {
680  float pt[3];
681  int i;
682  int ptX, ptY, ptZ;
683  double resx, resy, resz;
684 
685  geovol_slice *slice;
686 
687  G_debug(5, "gvld_wire_slices");
688 
689  gsd_pushmatrix();
690 
691  /* shading */
693  /* set color mode */
695  /* do scale and set volume position */
696  gsd_do_scale(1);
697  gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
698 
699  /* set color and line width */
700  gsd_color_func(0x0);
701  gsd_linewidth(1);
702 
703  /* loop in slices */
704  for (i = 0; i < gvl->n_slices; i++) {
705  slice = gvl->slice[i];
706 
707  /* initialize correct coords */
708  if (slice->dir == X) {
709  resx = gvl->yres;
710  resy = gvl->zres;
711  resz = gvl->xres;
712  ptX = Y;
713  ptY = Z;
714  ptZ = X;
715  }
716  else if (slice->dir == Y) {
717  resx = gvl->xres;
718  resy = gvl->zres;
719  resz = gvl->yres;
720  ptX = X;
721  ptY = Z;
722  ptZ = Y;
723  }
724  else {
725  resx = gvl->xres;
726  resy = gvl->yres;
727  resz = gvl->zres;
728  ptX = X;
729  ptY = Y;
730  ptZ = Z;
731  }
732 
733  gsd_bgnline();
734 
735  /* first slice edge */
736  pt[ptX] = slice->x1 * resx;
737  pt[ptY] = slice->y1 * resy;
738  pt[ptZ] = slice->z1 * resz;
739  ;
740  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
741  gsd_vert_func(pt);
742 
743  pt[ptX] = slice->x1 * resx;
744  pt[ptY] = slice->y1 * resy;
745  pt[ptZ] = slice->z2 * resz;
746  ;
747  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
748  gsd_vert_func(pt);
749 
750  pt[ptX] = slice->x2 * resx;
751  pt[ptY] = slice->y2 * resy;
752  pt[ptZ] = slice->z2 * resz;
753  ;
754  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
755  gsd_vert_func(pt);
756 
757  pt[ptX] = slice->x2 * resx;
758  pt[ptY] = slice->y2 * resy;
759  pt[ptZ] = slice->z1 * resz;
760  ;
761  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
762  gsd_vert_func(pt);
763 
764  pt[ptX] = slice->x1 * resx;
765  pt[ptY] = slice->y1 * resy;
766  pt[ptZ] = slice->z1 * resz;
767  ;
768  pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
769  gsd_vert_func(pt);
770 
771  gsd_endline();
772  }
773 
774  gsd_set_material(1, 1, 0., 0., 0x0);
775  gsd_popmatrix();
776 
777  return (0);
778 }
779 
780 /*!
781  \brief Draw volume bounding box
782 
783  \param gvl pointer to geovol struct
784 
785  \return 0
786  */
788 {
789  float pt[3];
790 
791  G_debug(5, "gvld_wind3_box(): id=%d", gvl->gvol_id);
792 
793  gsd_pushmatrix();
794 
795  /* shading */
797  /* set color mode */
799  /* do scale and set volume position */
800  gsd_do_scale(1);
801  gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
802 
803  /* set color and line width */
804  gsd_color_func(0x0);
805  gsd_linewidth(1);
806 
807  /* draw box */
808 
809  /* front edges */
810  gsd_bgnline();
811  pt[X] = 0;
812  pt[Y] = 0;
813  pt[Z] = 0;
814  gsd_vert_func(pt);
815  pt[X] = (gvl->cols - 1) * gvl->xres;
816  pt[Y] = 0;
817  pt[Z] = 0;
818  gsd_vert_func(pt);
819  pt[X] = (gvl->cols - 1) * gvl->xres;
820  pt[Y] = (gvl->rows - 1) * gvl->yres;
821  pt[Z] = 0;
822  gsd_vert_func(pt);
823  pt[X] = 0;
824  pt[Y] = (gvl->rows - 1) * gvl->yres;
825  pt[Z] = 0;
826  gsd_vert_func(pt);
827  pt[X] = 0;
828  pt[Y] = 0;
829  pt[Z] = 0;
830  gsd_vert_func(pt);
831  gsd_endline();
832 
833  /* back edges */
834  gsd_bgnline();
835  pt[X] = 0;
836  pt[Y] = 0;
837  pt[Z] = (gvl->depths - 1) * gvl->zres;
838  gsd_vert_func(pt);
839  pt[X] = (gvl->cols - 1) * gvl->xres;
840  pt[Y] = 0;
841  pt[Z] = (gvl->depths - 1) * gvl->zres;
842  gsd_vert_func(pt);
843  pt[X] = (gvl->cols - 1) * gvl->xres;
844  pt[Y] = (gvl->rows - 1) * gvl->yres;
845  pt[Z] = (gvl->depths - 1) * gvl->zres;
846  gsd_vert_func(pt);
847  pt[X] = 0;
848  pt[Y] = (gvl->rows - 1) * gvl->yres;
849  pt[Z] = (gvl->depths - 1) * gvl->zres;
850  gsd_vert_func(pt);
851  pt[X] = 0;
852  pt[Y] = 0;
853  pt[Z] = (gvl->depths - 1) * gvl->zres;
854  gsd_vert_func(pt);
855  gsd_endline();
856 
857  /* others edges */
858  gsd_bgnline();
859  pt[X] = 0;
860  pt[Y] = 0;
861  pt[Z] = 0;
862  gsd_vert_func(pt);
863  pt[X] = 0;
864  pt[Y] = 0;
865  pt[Z] = (gvl->depths - 1) * gvl->zres;
866  gsd_vert_func(pt);
867  gsd_endline();
868 
869  gsd_bgnline();
870  pt[X] = (gvl->cols - 1) * gvl->xres;
871  pt[Y] = 0;
872  pt[Z] = 0;
873  gsd_vert_func(pt);
874  pt[X] = (gvl->cols - 1) * gvl->xres;
875  pt[Y] = 0;
876  pt[Z] = (gvl->depths - 1) * gvl->zres;
877  gsd_vert_func(pt);
878  gsd_endline();
879 
880  gsd_bgnline();
881  pt[X] = 0;
882  pt[Y] = (gvl->rows - 1) * gvl->yres;
883  pt[Z] = 0;
884  gsd_vert_func(pt);
885  pt[X] = 0;
886  pt[Y] = (gvl->rows - 1) * gvl->yres;
887  pt[Z] = (gvl->depths - 1) * gvl->zres;
888  gsd_vert_func(pt);
889  gsd_endline();
890 
891  gsd_bgnline();
892  pt[X] = (gvl->cols - 1) * gvl->xres;
893  pt[Y] = (gvl->rows - 1) * gvl->yres;
894  pt[Z] = 0;
895  gsd_vert_func(pt);
896  pt[X] = (gvl->cols - 1) * gvl->xres;
897  pt[Y] = (gvl->rows - 1) * gvl->yres;
898  pt[Z] = (gvl->depths - 1) * gvl->zres;
899  gsd_vert_func(pt);
900  gsd_endline();
901 
902  gsd_popmatrix();
903 
904  return (0);
905 }
CELL_ENTRY cell_table[256]
Definition: cell_table.c:3
void G_free(void *)
Free allocated memory.
Definition: gis/alloc.c:150
#define G_malloc(n)
Definition: defs/gis.h:94
int G_debug(int, const char *,...) __attribute__((format(printf
void gsd_endtmesh(void)
ADD.
Definition: gsd_prim.c:307
void gsd_pushmatrix(void)
Push the current matrix stack.
Definition: gsd_prim.c:511
char * gvl_file_get_name(int)
Get file name for given handle.
Definition: gvl_file.c:165
void gsd_getwindow(int *, int *, double *, double *)
Get viewport.
Definition: gsd_prim.c:554
void gsd_do_scale(int)
Set current scale.
Definition: gsd_views.c:355
int gvl_slices_calc(geovol *)
Calculate slices for given volume set.
Definition: gvl_calc.c:1034
void gsd_shademodel(int)
Set shaded model.
Definition: gsd_prim.c:419
void gsd_bgnpolygon(void)
Delimit the vertices of a primitive or a group of like primitives.
Definition: gsd_prim.c:372
int gvl_isosurf_calc(geovol *)
Fill data structure with computed isosurfaces polygons.
Definition: gvl_calc.c:585
void gsd_color_func(unsigned int)
Set current color.
Definition: gsd_prim.c:698
void gsd_translate(float, float, float)
Multiply the current matrix by a translation matrix.
Definition: gsd_prim.c:539
void gsd_popmatrix(void)
Pop the current matrix stack.
Definition: gsd_prim.c:501
void gsd_zwritemask(unsigned long)
Write out z-mask.
Definition: gsd_prim.c:241
void gsd_linewidth(short)
Set width of rasterized lines.
Definition: gsd_prim.c:267
void gsd_endline(void)
End line.
Definition: gsd_prim.c:407
void gsd_colormode(int)
Set color mode.
Definition: gsd_prim.c:98
void GS_get_scale(float *, float *, float *, int)
Get axis scale.
Definition: gs2.c:3238
void gsd_set_material(int, int, float, float, int)
Set material.
Definition: gsd_prim.c:803
void gsd_bgnline(void)
Begin line.
Definition: gsd_prim.c:397
void gsd_blend(int)
Specify pixel arithmetic.
Definition: gsd_prim.c:994
void gsd_vert_func(float *)
ADD.
Definition: gsd_prim.c:686
void gsd_bgntmesh(void)
ADD.
Definition: gsd_prim.c:297
int GS_check_cancel(void)
Check for cancel.
Definition: gsx.c:30
void gsd_endpolygon(void)
Delimit the vertices of a primitive or a group of like primitives.
Definition: gsd_prim.c:387
void gsd_litvert_func(float *, unsigned long, float *)
Set the current normal vector & specify vertex.
Definition: gsd_prim.c:657
#define UNUSED
A macro for an attribute, if attached to a variable, indicating that the variable is not used.
Definition: gis.h:46
#define DISTANCE_2(x1, y1, x2, y2)
Definition: gvld.c:433
int gvld_isosurf(geovol *gvl)
Draw volume isosurfaces.
Definition: gvld.c:92
int gvld_slice(geovol *gvl, int ndx)
Draw slice.
Definition: gvld.c:500
int gvld_wire_isosurf(geovol *gvl UNUSED)
Draw volume isosurface in draw mode.
Definition: gvld.c:423
int gvld_wire_slices(geovol *gvl)
Draw wire slices.
Definition: gvld.c:678
int gvld_wind3_box(geovol *gvl)
Draw volume bounding box.
Definition: gvld.c:787
int gvld_slices(geovol *gvl)
Draw slices.
Definition: gvld.c:443
int gvld_wire_vol(geovol *gvl)
Draw volume in wire mode (bounding box)
Definition: gvld.c:69
#define READ()
Definition: gvld.c:28
int gvld_vol(geovol *gvl)
Draw volume set (slices and isosurfaces)
Definition: gvld.c:38
OGSF library -.
float g
Definition: named_colr.c:7
OGSF header file (structures)
#define CM_DIFFUSE
Definition: ogsf.h:151
#define X
Definition: ogsf.h:140
#define ATT_COLOR
Definition: ogsf.h:76
#define ATT_EMIT
Definition: ogsf.h:80
#define Z
Definition: ogsf.h:142
#define ATT_SHINE
Definition: ogsf.h:79
#define Y
Definition: ogsf.h:141
#define MAP_ATT
Definition: ogsf.h:85
#define CM_COLOR
Definition: ogsf.h:148
#define DM_GOURAUD
Definition: ogsf.h:56
#define DM_FLAT
Definition: ogsf.h:57
#define CONST_ATT
Definition: ogsf.h:86
#define ATT_TRANSP
Definition: ogsf.h:78
double b
Definition: r_raster.c:39
double r
Definition: r_raster.c:39
int npolys
Definition: viz.h:70
int polys[30]
Definition: viz.h:71
int nedges
Definition: viz.h:68
int edges[12]
Definition: viz.h:69
Definition: ogsf.h:426
IFLAG slice_draw_mode
Definition: ogsf.h:447
int n_slices
Definition: ogsf.h:444
int hfile
Definition: ogsf.h:430
int depths
Definition: ogsf.h:431
geovol_slice * slice[MAX_SLICES]
Definition: ogsf.h:445
int slice_z_mod
Definition: ogsf.h:446
float x_trans
Definition: ogsf.h:436
int isosurf_z_mod
Definition: ogsf.h:441
int slice_y_mod
Definition: ogsf.h:446
int isosurf_y_mod
Definition: ogsf.h:441
double zres
Definition: ogsf.h:433
int cols
Definition: ogsf.h:431
int isosurf_x_mod
Definition: ogsf.h:441
IFLAG isosurf_draw_mode
Definition: ogsf.h:442
double yres
Definition: ogsf.h:433
float z_trans
Definition: ogsf.h:436
int gvol_id
Definition: ogsf.h:427
int slice_x_mod
Definition: ogsf.h:446
float y_trans
Definition: ogsf.h:436
geovol_isosurf * isosurf[MAX_ISOSURFS]
Definition: ogsf.h:440
int n_isosurfs
Definition: ogsf.h:439
double xres
Definition: ogsf.h:433
int rows
Definition: ogsf.h:431
float constant
Definition: ogsf.h:403
IFLAG att_src
Definition: ogsf.h:399
geovol_isosurf_att att[MAX_ATTS]
Definition: ogsf.h:411
int inout_mode
Definition: ogsf.h:410
unsigned char * data
Definition: ogsf.h:420
float z1
Definition: ogsf.h:419
float x1
Definition: ogsf.h:419
float z2
Definition: ogsf.h:419
float y1
Definition: ogsf.h:419
int dir
Definition: ogsf.h:418
float x2
Definition: ogsf.h:419
float y2
Definition: ogsf.h:419
int transp
Definition: ogsf.h:423
#define x