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