GRASS Programmer's Manual  6.4.2(2012)
gvld.c
Go to the documentation of this file.
00001 
00019 #include <math.h>
00020 
00021 #include <grass/gis.h>
00022 #include <grass/gstypes.h>
00023 
00024 #include "mc33_table.h"
00025 
00026 /* usefull macros */
00027 #define READ() gvl_read_char(pos[i]++, gvl->isosurf[i]->data)
00028 
00037 int gvld_vol(geovol *gvl)
00038 {
00039     G_debug(5, "gvld_vol(): id=%d", gvl->gvol_id);
00040 
00041     /* SLICES */
00042     /* calculate slices data, if slices changed */
00043     if (0 > gvl_slices_calc(gvl))
00044         return (-1);
00045     /* draw slices */
00046     if (0 > gvld_slices(gvl))
00047         return (-1);
00048 
00049     /* ISOSURFACES */
00050     /* calculate isosurfaces data, if isosurfaces changed */
00051     if (0 > gvl_isosurf_calc(gvl))
00052         return (-1);
00053     /* draw isosurfaces */
00054     if (0 > gvld_isosurf(gvl))
00055         return (-1);
00056 
00057     return (1);
00058 }
00059 
00068 int gvld_wire_vol(geovol * gvl)
00069 {
00070     G_debug(5, "gvld_vol(): id=%d", gvl->gvol_id);
00071 
00072     gvld_wind3_box(gvl);
00073 
00074     if (0 > gvld_wire_slices(gvl))
00075         return (-1);
00076 
00077     if (0 > gvld_wire_isosurf(gvl))
00078         return (-1);
00079 
00080     return (1);
00081 }
00082 
00091 int gvld_isosurf(geovol * gvl)
00092 {
00093     float tx, ty, tz;
00094     int cols, rows, depths;
00095     int x, y, z, i, iv;
00096     float xc, yc, zc;
00097     float xres, yres, zres;
00098 
00099     int j, p, num, c_ndx, crnt_ev;
00100     float n[3], pt[4];
00101 
00102     int n_i = gvl->n_isosurfs;
00103 
00104     int *check_color, *check_transp, *check_material, *check_emis,
00105         *check_shin;
00106     float *kem, *ksh, pkem, pksh;
00107     unsigned int *ktrans, *curcolor;
00108     int pktransp = 0;
00109 
00110     int *pos, *nz, *e_dl, tmp_pos, edge_pos[12];
00111 
00112     GLdouble modelMatrix[16], projMatrix[16];
00113     GLint viewport[4];
00114     GLint window[4];
00115 
00116     geovol_isosurf *isosurf;
00117 
00118     /* Allocate memory for arrays */
00119 
00120     check_color = G_malloc(n_i * sizeof(int));
00121     check_transp = G_malloc(n_i * sizeof(int));
00122     check_material = G_malloc(n_i * sizeof(int));
00123     check_emis = G_malloc(n_i * sizeof(int));
00124     check_shin = G_malloc(n_i * sizeof(int));
00125 
00126     kem = G_malloc(n_i * sizeof(float));
00127     ksh = G_malloc(n_i * sizeof(float));
00128 
00129     ktrans = G_malloc(n_i * sizeof(unsigned int));
00130     curcolor = G_malloc(n_i * sizeof(unsigned int));
00131 
00132     pos = G_malloc(n_i * sizeof(int));
00133     nz = G_malloc(n_i * sizeof(int));
00134     e_dl = G_malloc(n_i * sizeof(int));
00135 
00136     G_debug(5, "gvld_isosurf():");
00137     for (i = 0; i < gvl->n_isosurfs; i++) {
00138         G_debug(5, "  start : gvl: %s isosurf : %d\n",
00139                 gvl_file_get_name(gvl->hfile), i);
00140     }
00141 
00142     /* shade */
00143     gsd_shademodel(gvl->isosurf_draw_mode & DM_GOURAUD);
00144 
00145     /* scaling */
00146     GS_get_scale(&tx, &ty, &tz, 1);
00147 
00148     /* set number of cols, rows, dephs */
00149     cols = gvl->cols / gvl->isosurf_x_mod;
00150     rows = gvl->rows / gvl->isosurf_y_mod;
00151     depths = gvl->depths / gvl->isosurf_z_mod;
00152 
00153     /* set x,y,z resolution */
00154     xres =
00155         /*((float) gvl->cols) / ((float) cols) */ gvl->isosurf_x_mod *
00156         gvl->xres;
00157     yres =
00158         /*((float) gvl->rows) / ((float) rows) */ gvl->isosurf_y_mod *
00159         gvl->yres;
00160     zres =
00161         /*((float) gvl->depths) / ((float) depths) */ gvl->isosurf_z_mod *
00162         gvl->zres;
00163 
00164     /* get viewport */
00165     gsd_getwindow(window, viewport, modelMatrix, projMatrix);
00166 
00167     /* adjust window */
00168     window[0] += (int)(yres * 2);
00169     window[1] -= (int)(yres * 2);
00170     window[2] -= (int)(xres * 2);
00171     window[3] += (int)(xres * 2);
00172 
00173     gsd_colormode(CM_DIFFUSE);
00174     gsd_pushmatrix();
00175     gsd_do_scale(1);
00176     gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
00177 
00178     pkem = 1.0;
00179     pksh = 1.0;
00180 
00181     /* set default attribute values for isosurfaces */
00182     for (i = 0; i < gvl->n_isosurfs; i++) {
00183         isosurf = gvl->isosurf[i];
00184 
00185         /* init isosurf one cube edge datalength */
00186         e_dl[i] = 4;
00187 
00188         /* transparency */
00189         check_transp[i] = 0;
00190         ktrans[i] = (255 << 24);
00191         if (CONST_ATT == isosurf->att[ATT_TRANSP].att_src &&
00192             isosurf->att[ATT_TRANSP].constant != 0.0) {
00193             ktrans[i] = (255 - (int)isosurf->att[ATT_TRANSP].constant) << 24;
00194         }
00195         else if (MAP_ATT == isosurf->att[ATT_TRANSP].att_src) {
00196             check_transp[i] = 1;
00197             e_dl[i]++;
00198         }
00199 
00200         /* emis */
00201         check_emis[i] = 0;
00202         kem[i] = 0.0;
00203         if (CONST_ATT == isosurf->att[ATT_EMIT].att_src) {
00204             kem[i] = isosurf->att[ATT_EMIT].constant / 255.;
00205         }
00206         else if (MAP_ATT == isosurf->att[ATT_EMIT].att_src) {
00207             check_emis[i] = 1;
00208             e_dl[i]++;
00209         }
00210 
00211         /* shin */
00212         check_shin[i] = 0;
00213         ksh[i] = 0.0;
00214         if (CONST_ATT == isosurf->att[ATT_SHINE].att_src) {
00215             ksh[i] = isosurf->att[ATT_SHINE].constant / 255.;
00216         }
00217         else if (MAP_ATT == isosurf->att[ATT_SHINE].att_src) {
00218             check_shin[i] = 1;
00219             e_dl[i]++;
00220         }
00221 
00222         /* color */
00223         check_color[i] = 0;
00224         curcolor[i] = 0.0;
00225         if (CONST_ATT == isosurf->att[ATT_COLOR].att_src) {
00226             curcolor[i] = (int)isosurf->att[ATT_COLOR].constant;
00227         }
00228         else if (MAP_ATT == isosurf->att[ATT_COLOR].att_src) {
00229             check_color[i] = 1;
00230             e_dl[i] += 3;
00231         }
00232 
00233         /* check material */
00234         check_material[i] = (check_shin[i] || check_emis[i] ||
00235                              (kem[i] && check_color[i]));
00236 
00237         /* set position in data */
00238         pos[i] = 0;
00239         nz[i] = 0;
00240     }
00241 
00242     G_debug(5, "  intialize OK");
00243 
00244     for (z = 0; z < depths - 1; z++) {
00245         zc = z * zres;
00246 
00247         if (GS_check_cancel()) {
00248             for (i = 0; i < gvl->n_isosurfs; i++) {
00249                 G_debug(5, "  break : isosurf : %d datalength : %d B\n",
00250                         i, pos[i]);
00251             }
00252 
00253             gsd_set_material(1, 1, 0., 0., 0x0);
00254             gsd_popmatrix();
00255             gsd_blend(0);
00256             gsd_zwritemask(0xffffffff);
00257 
00258             return (-1);
00259         }
00260 
00261         for (y = 0; y < rows - 1; y++) {
00262             yc = ((rows - 1) * yres) - (y * yres);
00263 
00264             for (x = 0; x < cols - 1; x++) {
00265                 xc = x * xres;
00266 
00267                 for (i = 0; i < gvl->n_isosurfs; i++) {
00268 
00269                     /* read cube index */
00270                     if (nz[i] != 0) {
00271                         nz[i]--;
00272                         continue;
00273                     }
00274                     else {
00275                         c_ndx = READ();
00276                         if (c_ndx == 0) {
00277                             nz[i] = READ() - 1;
00278                             continue;
00279                         }
00280                         else {
00281                             c_ndx = (c_ndx - 1) * 256 + READ();
00282                         }
00283                     }
00284 
00285                     /* save position */
00286                     tmp_pos = pos[i];
00287 
00288                     /* set position for each cube edge data */
00289                     iv = 0;
00290                     for (j = 0; j < cell_table[c_ndx].nedges; j++) {
00291                         if (cell_table[c_ndx].edges[j] == 12)
00292                             iv = 1;
00293 
00294                         edge_pos[cell_table[c_ndx].edges[j]] =
00295                             pos[i] + j * e_dl[i];
00296                     }
00297 
00298                     /* enable/disable blending and depth buffer writing */
00299                     if (check_transp[i] || (ktrans[i] >> 24) < 255) {
00300                         if (!pktransp) {
00301                             gsd_blend(1);
00302                             gsd_zwritemask(0);
00303                         }
00304                     }
00305                     else if (pktransp) {
00306                         gsd_blend(0);
00307                         gsd_zwritemask(0xffffffff);
00308                         pktransp = 0;
00309                     }
00310 
00311                     /* draw cube polygons */
00312                     for (p = 0, num = 0; num < cell_table[c_ndx].npolys;
00313                          num++) {
00314                         gsd_bgnpolygon();
00315 
00316                         for (j = 0; j < 3; j++) {
00317                             crnt_ev = cell_table[c_ndx].polys[p];
00318                             /* set position in data to current edge data */
00319                             pos[i] = edge_pos[crnt_ev];
00320 
00321                             /* triagle vertex */
00322                             if (crnt_ev == 12) {
00323                                 pt[X] = xc + (READ() / 255. * xres);
00324                                 pt[Y] = yc + (-(READ() / 255. * yres));
00325                                 pt[Z] = zc + (READ() / 255. * zres);
00326                             }
00327                             else {
00328                                 pt[edge_vert_pos[crnt_ev][0]] = READ() / 255.;
00329                                 pt[edge_vert_pos[crnt_ev][1]] =
00330                                     edge_vert_pos[crnt_ev][2];
00331                                 pt[edge_vert_pos[crnt_ev][3]] =
00332                                     edge_vert_pos[crnt_ev][4];
00333 
00334                                 pt[X] = xc + (pt[X] * xres);
00335                                 pt[Y] = yc + (-(pt[Y] * yres));
00336                                 pt[Z] = zc + (pt[Z] * zres);
00337                             }
00338 
00339                             n[X] = (READ() / 127. - 1.) / xres;
00340                             n[Y] = (-(READ() / 127. - 1.)) / yres;
00341                             n[Z] = (READ() / 127. - 1.) / zres;
00342 
00343                             if (gvl->isosurf[i]->inout_mode) {
00344                                 n[X] *= -1;
00345                                 n[Y] *= -1;
00346                                 n[Z] *= -1;
00347                             }
00348 
00349                             if (check_color[i])
00350                                 curcolor[i] =
00351                                     (READ() & 0xff) | ((READ() & 0xff) << 8) |
00352                                     ((READ() & 0xff) << 16);
00353 
00354                             if (check_transp[i])
00355                                 ktrans[i] = READ() << 24;;
00356 
00357                             if (check_shin[i])
00358                                 ksh[i] = ((float)READ()) / 255.;
00359 
00360                             if (check_emis[i])
00361                                 kem[i] = ((float)READ()) / 255.;
00362 
00363                             if (pksh != ksh[i] || pkem != kem[i] ||
00364                                 (kem[i] && check_color[i])) {
00365                                 pksh = ksh[i];
00366                                 pkem = kem[i];
00367                                 gsd_set_material(1, 1, ksh[i], kem[i],
00368                                                  (int)curcolor);
00369                             }
00370 
00371                             gsd_litvert_func(n, ktrans[i] | curcolor[i], pt);
00372                             p++;
00373                         }
00374 
00375                         gsd_endpolygon();
00376                     }
00377 
00378                     /* set position to next cube */
00379                     pos[i] =
00380                         tmp_pos + cell_table[c_ndx].nedges * e_dl[i] +
00381                         (iv ? 2 : 0);
00382                 }
00383 
00384             }
00385 
00386         }
00387 
00388     }
00389 
00390     for (i = 0; i < gvl->n_isosurfs; i++) {
00391         G_debug(5, "  end : isosurf : %d datalength : %d B\n", i, pos[i]);
00392     }
00393 
00394     gsd_set_material(1, 1, 0., 0., 0x0);
00395     gsd_popmatrix();
00396     gsd_blend(0);
00397     gsd_zwritemask(0xffffffff);
00398 
00399     return (0);
00400 }
00401 
00409 int gvld_wire_isosurf(geovol * gvl)
00410 {
00411     return (0);
00412 }
00413 
00414 /************************************************************************/
00415 /* SLICES */
00416 
00417 /************************************************************************/
00418 
00419 #define DISTANCE_2(x1, y1, x2, y2)      sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))
00420 
00428 int gvld_slices(geovol * gvl)
00429 {
00430     float tx, ty, tz;
00431     int i;
00432 
00433     GLdouble modelMatrix[16], projMatrix[16];
00434     GLint viewport[4];
00435     GLint window[4];
00436 
00437     G_debug(5, "gvld_slices");
00438 
00439     /* shade */
00440     gsd_shademodel(gvl->slice_draw_mode & DM_GOURAUD);
00441 
00442     /* scaling */
00443     GS_get_scale(&tx, &ty, &tz, 1);
00444 
00445     /* get viewport */
00446     gsd_getwindow(window, viewport, modelMatrix, projMatrix);
00447 
00448     gsd_colormode(CM_COLOR);
00449     gsd_pushmatrix();
00450     gsd_do_scale(1);
00451     gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
00452 
00453     for (i = 0; i < gvl->n_slices; i++) {
00454         gsd_blend(0);
00455         gsd_zwritemask(0xffffffff);
00456 
00457         if (gvl->slice[i]->transp == 0)
00458             gvld_slice(gvl, i);
00459     }
00460 
00461     for (i = 0; i < gvl->n_slices; i++) {
00462         gsd_blend(1);
00463         gsd_zwritemask(0x0);
00464 
00465         if (gvl->slice[i]->transp > 0)
00466             gvld_slice(gvl, i);
00467     }
00468 
00469     gsd_set_material(1, 1, 0., 0., 0x0);
00470     gsd_popmatrix();
00471     gsd_blend(0);
00472     gsd_zwritemask(0xffffffff);
00473 
00474     return (0);
00475 }
00476 
00485 int gvld_slice(geovol * gvl, int ndx)
00486 {
00487     geovol_slice *slice;
00488 
00489     int color, offset, transp;
00490     float n[3], pt[4];
00491     float x, nextx, y, nexty, z, stepx, stepy, stepz;
00492     int cols, rows, c, r;
00493     float f_cols, f_rows, distxy, distz, modx, mody, modz, modxy;
00494     int ptX, ptY, ptZ, resx, resy, resz;
00495 
00496     /* current slice */
00497     slice = gvl->slice[ndx];
00498 
00499     /* distance between slice def. pts */
00500     distxy = DISTANCE_2(slice->x2, slice->y2, slice->x1, slice->y1);
00501     distz = fabsf(slice->z2 - slice->z1);
00502 
00503     /* distance between slice def pts is zero - zero slice */
00504     if (distxy == 0. || distz == 0.) {
00505         return (1);
00506     }
00507 
00508     /* set slice mod, resolution and set correct coords */
00509     if (slice->dir == X) {
00510         modx = gvl->slice_y_mod;
00511         mody = gvl->slice_z_mod;
00512         modz = gvl->slice_x_mod;
00513         resx = gvl->yres;
00514         resy = gvl->zres;
00515         resz = gvl->xres;
00516         ptX = Y;
00517         ptY = Z;
00518         ptZ = X;
00519     }
00520     else if (slice->dir == Y) {
00521         modx = gvl->slice_x_mod;
00522         mody = gvl->slice_z_mod;
00523         modz = gvl->slice_y_mod;
00524         resx = gvl->xres;
00525         resy = gvl->zres;
00526         resz = gvl->yres;
00527         ptX = X;
00528         ptY = Z;
00529         ptZ = Y;
00530     }
00531     else {
00532         modx = gvl->slice_x_mod;
00533         mody = gvl->slice_y_mod;
00534         modz = gvl->slice_z_mod;
00535         resx = gvl->xres;
00536         resy = gvl->yres;
00537         resz = gvl->zres;
00538         ptX = X;
00539         ptY = Y;
00540         ptZ = Z;
00541     }
00542 
00543     /* x,y mod */
00544     modxy =
00545         DISTANCE_2((slice->x2 - slice->x1) / distxy * modx,
00546                    (slice->y2 - slice->y1) / distxy * mody, 0., 0.);
00547 
00548     /* cols/rows of slice */
00549     f_cols = distxy / modxy;
00550     cols = f_cols > (int)f_cols ? (int)f_cols + 1 : (int)f_cols;
00551 
00552     f_rows = distz / modz;
00553     rows = f_rows > (int)f_rows ? (int)f_rows + 1 : (int)f_rows;
00554 
00555     /* step in x,y for each row of slice */
00556     stepx = (slice->x2 - slice->x1) / f_cols;
00557     stepy = (slice->y2 - slice->y1) / f_cols;
00558     stepz = (slice->z2 - slice->z1) / f_rows;
00559 
00560     /* set x,y intially to first slice pt */
00561     x = (slice->x1);
00562     y = (slice->y1);
00563 
00564     /* set next draw pt */
00565     if (f_cols < 1.) {
00566         nextx = x + stepx * f_cols;
00567         nexty = y + stepy * f_cols;
00568     }
00569     else {
00570         nextx = x + stepx;
00571         nexty = y + stepy;
00572     }
00573 
00574     /* set transparency */
00575     if (slice->transp > 0) {
00576         transp = (255 - slice->transp) << 24;
00577     }
00578     else {
00579         transp = 0x0;
00580     }
00581 
00582     /* loop in slice cols */
00583     for (c = 0; c < cols; c++) {
00584 
00585         /* set z to slice z1 pt */
00586         z = slice->z1;
00587 
00588         /* begin draw one row - triangle strip */
00589         gsd_bgntmesh();
00590 
00591         /* loop in slice rows */
00592         for (r = 0; r < rows + 1; r++) {
00593             /* offset to data - 1. column */
00594             offset = (c + 1) * (rows + 1) * 3 + r * 3;
00595 
00596             /* get color from slice data */
00597             color = (slice->data[offset] & 0xff) |
00598                 ((slice->data[offset + 1] & 0xff) << 8) |
00599                 ((slice->data[offset + 2] & 0xff) << 16);
00600 
00601             /* triagle vertices */
00602             pt[ptX] = nextx * resx;
00603             pt[ptY] = nexty * resy;
00604             pt[ptZ] = z * resz;
00605 
00606             pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00607             gsd_litvert_func(n, (unsigned int)transp | color, pt);
00608 
00609             /* offset to data - 2. column */
00610             offset = c * (rows + 1) * 3 + r * 3;
00611 
00612             /* get color from slice data */
00613             color = (slice->data[offset] & 0xff) |
00614                 ((slice->data[offset + 1] & 0xff) << 8) |
00615                 ((slice->data[offset + 2] & 0xff) << 16);
00616 
00617             /* set triangle vertices */
00618             pt[ptX] = x * resx;
00619             pt[ptY] = y * resy;
00620             pt[ptZ] = z * resz;
00621 
00622             pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00623             gsd_litvert_func(n, (unsigned int)transp | color, pt);
00624 
00625             if (r + 1 > f_rows) {
00626                 z += stepz * (f_rows - (float)r);
00627             }
00628             else {
00629                 z += stepz;
00630             }
00631         }
00632 
00633         gsd_endtmesh();
00634 
00635         /* step */
00636         if (c + 2 > f_cols) {
00637             x += stepx;
00638             nextx += stepx * (f_cols - (float)(c + 1));
00639             y += stepy;
00640             nexty += stepy * (f_cols - (float)(c + 1));
00641         }
00642         else {
00643             x += stepx;
00644             nextx += stepx;
00645             y += stepy;
00646             nexty += stepy;
00647         }
00648     }
00649 
00650     gsd_blend(0);
00651     gsd_zwritemask(0xffffffff);
00652 
00653     return (1);
00654 }
00655 
00663 int gvld_wire_slices(geovol * gvl)
00664 {
00665     float pt[3];
00666     int i;
00667     int ptX, ptY, ptZ, resx, resy, resz;
00668 
00669     geovol_slice *slice;
00670 
00671     G_debug(5, "gvld_wire_slices");
00672 
00673     gsd_pushmatrix();
00674 
00675     /* shading */
00676     gsd_shademodel(DM_FLAT);
00677     /* set color mode */
00678     gsd_colormode(CM_COLOR);
00679     /* do scale and set volume position */
00680     gsd_do_scale(1);
00681     gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
00682 
00683     /* set color and line width */
00684     gsd_color_func(0x0);
00685     gsd_linewidth(1);
00686 
00687     /* loop in slices */
00688     for (i = 0; i < gvl->n_slices; i++) {
00689         slice = gvl->slice[i];
00690 
00691         /* intialize correct coords */
00692         if (slice->dir == X) {
00693             resx = gvl->yres;
00694             resy = gvl->zres;
00695             resz = gvl->xres;
00696             ptX = Y;
00697             ptY = Z;
00698             ptZ = X;
00699         }
00700         else if (slice->dir == Y) {
00701             resx = gvl->xres;
00702             resy = gvl->zres;
00703             resz = gvl->yres;
00704             ptX = X;
00705             ptY = Z;
00706             ptZ = Y;
00707         }
00708         else {
00709             resx = gvl->xres;
00710             resy = gvl->yres;
00711             resz = gvl->zres;
00712             ptX = X;
00713             ptY = Y;
00714             ptZ = Z;
00715         }
00716 
00717         gsd_bgnline();
00718 
00719         /* first slice edge */
00720         pt[ptX] = slice->x1 * resx;
00721         pt[ptY] = slice->y1 * resy;
00722         pt[ptZ] = slice->z1 * resz;;
00723         pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00724         gsd_vert_func(pt);
00725 
00726         pt[ptX] = slice->x1 * resx;
00727         pt[ptY] = slice->y1 * resy;
00728         pt[ptZ] = slice->z2 * resz;;
00729         pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00730         gsd_vert_func(pt);
00731 
00732         pt[ptX] = slice->x2 * resx;
00733         pt[ptY] = slice->y2 * resy;
00734         pt[ptZ] = slice->z2 * resz;;
00735         pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00736         gsd_vert_func(pt);
00737 
00738         pt[ptX] = slice->x2 * resx;
00739         pt[ptY] = slice->y2 * resy;
00740         pt[ptZ] = slice->z1 * resz;;
00741         pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00742         gsd_vert_func(pt);
00743 
00744         pt[ptX] = slice->x1 * resx;
00745         pt[ptY] = slice->y1 * resy;
00746         pt[ptZ] = slice->z1 * resz;;
00747         pt[Y] = (gvl->rows - 1) * gvl->yres - pt[Y];
00748         gsd_vert_func(pt);
00749 
00750         gsd_endline();
00751     }
00752 
00753     gsd_set_material(1, 1, 0., 0., 0x0);
00754     gsd_popmatrix();
00755 
00756     return (0);
00757 }
00758 
00766 int gvld_wind3_box(geovol * gvl)
00767 {
00768     float pt[3];
00769 
00770     G_debug(5, "gvld_wind3_box(): id=%d", gvl->gvol_id);
00771 
00772     gsd_pushmatrix();
00773 
00774     /* shading */
00775     gsd_shademodel(DM_FLAT);
00776     /* set color mode */
00777     gsd_colormode(CM_COLOR);
00778     /* do scale and set volume position */
00779     gsd_do_scale(1);
00780     gsd_translate(gvl->x_trans, gvl->y_trans, gvl->z_trans);
00781 
00782     /* set color and line width */
00783     gsd_color_func(0x0);
00784     gsd_linewidth(1);
00785 
00786     /* draw box */
00787 
00788     /* front edges */
00789     gsd_bgnline();
00790     pt[X] = 0;
00791     pt[Y] = 0;
00792     pt[Z] = 0;
00793     gsd_vert_func(pt);
00794     pt[X] = (gvl->cols - 1) * gvl->xres;
00795     pt[Y] = 0;
00796     pt[Z] = 0;
00797     gsd_vert_func(pt);
00798     pt[X] = (gvl->cols - 1) * gvl->xres;
00799     pt[Y] = (gvl->rows - 1) * gvl->yres;
00800     pt[Z] = 0;
00801     gsd_vert_func(pt);
00802     pt[X] = 0;
00803     pt[Y] = (gvl->rows - 1) * gvl->yres;
00804     pt[Z] = 0;
00805     gsd_vert_func(pt);
00806     pt[X] = 0;
00807     pt[Y] = 0;
00808     pt[Z] = 0;
00809     gsd_vert_func(pt);
00810     gsd_endline();
00811 
00812     /* back edges */
00813     gsd_bgnline();
00814     pt[X] = 0;
00815     pt[Y] = 0;
00816     pt[Z] = (gvl->depths - 1) * gvl->zres;
00817     gsd_vert_func(pt);
00818     pt[X] = (gvl->cols - 1) * gvl->xres;
00819     pt[Y] = 0;
00820     pt[Z] = (gvl->depths - 1) * gvl->zres;
00821     gsd_vert_func(pt);
00822     pt[X] = (gvl->cols - 1) * gvl->xres;
00823     pt[Y] = (gvl->rows - 1) * gvl->yres;
00824     pt[Z] = (gvl->depths - 1) * gvl->zres;
00825     gsd_vert_func(pt);
00826     pt[X] = 0;
00827     pt[Y] = (gvl->rows - 1) * gvl->yres;
00828     pt[Z] = (gvl->depths - 1) * gvl->zres;
00829     gsd_vert_func(pt);
00830     pt[X] = 0;
00831     pt[Y] = 0;
00832     pt[Z] = (gvl->depths - 1) * gvl->zres;
00833     gsd_vert_func(pt);
00834     gsd_endline();
00835 
00836     /* others edges */
00837     gsd_bgnline();
00838     pt[X] = 0;
00839     pt[Y] = 0;
00840     pt[Z] = 0;
00841     gsd_vert_func(pt);
00842     pt[X] = 0;
00843     pt[Y] = 0;
00844     pt[Z] = (gvl->depths - 1) * gvl->zres;
00845     gsd_vert_func(pt);
00846     gsd_endline();
00847 
00848     gsd_bgnline();
00849     pt[X] = (gvl->cols - 1) * gvl->xres;
00850     pt[Y] = 0;
00851     pt[Z] = 0;
00852     gsd_vert_func(pt);
00853     pt[X] = (gvl->cols - 1) * gvl->xres;
00854     pt[Y] = 0;
00855     pt[Z] = (gvl->depths - 1) * gvl->zres;
00856     gsd_vert_func(pt);
00857     gsd_endline();
00858 
00859     gsd_bgnline();
00860     pt[X] = 0;
00861     pt[Y] = (gvl->rows - 1) * gvl->yres;
00862     pt[Z] = 0;
00863     gsd_vert_func(pt);
00864     pt[X] = 0;
00865     pt[Y] = (gvl->rows - 1) * gvl->yres;
00866     pt[Z] = (gvl->depths - 1) * gvl->zres;
00867     gsd_vert_func(pt);
00868     gsd_endline();
00869 
00870     gsd_bgnline();
00871     pt[X] = (gvl->cols - 1) * gvl->xres;
00872     pt[Y] = (gvl->rows - 1) * gvl->yres;
00873     pt[Z] = 0;
00874     gsd_vert_func(pt);
00875     pt[X] = (gvl->cols - 1) * gvl->xres;
00876     pt[Y] = (gvl->rows - 1) * gvl->yres;
00877     pt[Z] = (gvl->depths - 1) * gvl->zres;
00878     gsd_vert_func(pt);
00879     gsd_endline();
00880 
00881     gsd_popmatrix();
00882 
00883     return (0);
00884 }
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines