Doxygen Source Code Documentation

Main Page Alphabetical List Data Structures File List Data Fields Globals Search
vp_compAR1PB.c

00001 /*
00002  * DO NOT EDIT THIS FILE! It was created automatically by m4.
00003  */
00004 
00005 /*
00006  * Copyright (c) 1994 The Board of Trustees of The Leland Stanford
00007  * Junior University.  All rights reserved.
00008  * 
00009  * Permission to use, copy, modify and distribute this software and its
00010  * documentation for any purpose is hereby granted without fee, provided
00011  * that the above copyright notice and this permission notice appear in
00012  * all copies of this software and that you do not sell the software.
00013  * Commercial licensing is available by contacting the author.
00014  * 
00015  * THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND,
00016  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
00017  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
00018  * 
00019  * Author:
00020  *    Phil Lacroute
00021  *    Computer Systems Laboratory
00022  *    Electrical Engineering Dept.
00023  *    Stanford University
00024  */
00025 /*
00026  * vp_compA.m4
00027  *
00028  * Compositing routine for affine viewing transformations.
00029  *
00030  * Copyright (c) 1994 The Board of Trustees of The Leland Stanford
00031  * Junior University.  All rights reserved.
00032  *
00033  * Permission to use, copy, modify and distribute this software and its
00034  * documentation for any purpose is hereby granted without fee, provided
00035  * that the above copyright notice and this permission notice appear in
00036  * all copies of this software and that you do not sell the software.
00037  * Commercial licensing is available by contacting the author.
00038  * 
00039  * THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF ANY KIND,
00040  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
00041  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
00042  *
00043  * Author:
00044  *    Phil Lacroute
00045  *    Computer Systems Laboratory
00046  *    Electrical Engineering Dept.
00047  *    Stanford University
00048  */
00049 
00050 /*
00051  * $Date: 2001/12/17 16:16:22 $
00052  * $Revision: 1.1 $
00053  */
00054 
00055 #include "vp_global.h"
00056 
00057 
00058 
00059     
00060     
00061     
00062     
00063     
00064 
00065     
00066     
00067     
00068     
00069     
00070 
00071 
00072 #undef UNROLL_RUN_LOOP
00073 
00074 
00075 
00076 
00077 
00078 
00079 
00080 
00081 
00082 
00083 
00084 
00085 
00086 
00087 
00088 
00089 
00090 
00091 
00092 
00093 #define CALLBACK
00094 
00095 
00096 
00097 
00098 
00099 
00100 
00101 
00102 
00103 
00104 
00105 
00106 
00107 
00108 
00109 
00110 
00111 
00112 
00113 
00114 
00115 
00116 
00117 
00118 
00119 
00120 
00121 
00122 
00123 #define GRAYSCALE
00124     
00125     
00126     
00127     
00128 
00129 
00130 
00131 
00132 
00133 
00134 
00135 #define RAWVOLUME
00136         
00137         
00138         
00139         
00140         
00141         
00142         
00143 
00144 
00145 #undef INDEX_VOLUME
00146 
00147 
00148 
00149     
00150     
00151 
00152 
00153 
00154 
00155 
00156 
00157 
00158 
00159 /* codes indicating the types of a pair of runs in adjacent scanlines */
00160 #define ALL_ZERO        0       /* both runs are runs of zeros */
00161 #define TOP_NONZERO     1       /* run for top scanline has nonzero data */
00162 #define BOT_NONZERO     2       /* run for bottom scanline has nonzero data */
00163 #define ALL_NONZERO     3       /* both runs have nonzero data */
00164 
00165 /* codes indicating the types for the current left and right voxel pairs */
00166 #define ALL_ZERO__ALL_ZERO              ((ALL_ZERO << 2) | ALL_ZERO)
00167 #define ALL_ZERO__TOP_NONZERO           ((ALL_ZERO << 2) | TOP_NONZERO)
00168 #define ALL_ZERO__BOT_NONZERO           ((ALL_ZERO << 2) | BOT_NONZERO)
00169 #define ALL_ZERO__ALL_NONZERO           ((ALL_ZERO << 2) | ALL_NONZERO)
00170 #define TOP_NONZERO__ALL_ZERO           ((TOP_NONZERO << 2) | ALL_ZERO)
00171 #define TOP_NONZERO__TOP_NONZERO        ((TOP_NONZERO << 2) | TOP_NONZERO)
00172 #define TOP_NONZERO__BOT_NONZERO        ((TOP_NONZERO << 2) | BOT_NONZERO)
00173 #define TOP_NONZERO__ALL_NONZERO        ((TOP_NONZERO << 2) | ALL_NONZERO)
00174 #define BOT_NONZERO__ALL_ZERO           ((BOT_NONZERO << 2) | ALL_ZERO)
00175 #define BOT_NONZERO__TOP_NONZERO        ((BOT_NONZERO << 2) | TOP_NONZERO)
00176 #define BOT_NONZERO__BOT_NONZERO        ((BOT_NONZERO << 2) | BOT_NONZERO)
00177 #define BOT_NONZERO__ALL_NONZERO        ((BOT_NONZERO << 2) | ALL_NONZERO)
00178 #define ALL_NONZERO__ALL_ZERO           ((ALL_NONZERO << 2) | ALL_ZERO)
00179 #define ALL_NONZERO__TOP_NONZERO        ((ALL_NONZERO << 2) | TOP_NONZERO)
00180 #define ALL_NONZERO__BOT_NONZERO        ((ALL_NONZERO << 2) | BOT_NONZERO)
00181 #define ALL_NONZERO__ALL_NONZERO        ((ALL_NONZERO << 2) | ALL_NONZERO)
00182 
00183 #ifdef SKIP_ERT
00184 #define PIXEL_IS_OPAQUE(ipixel) 0
00185 #else
00186 #define PIXEL_IS_OPAQUE(ipixel) ((ipixel)->lnk != 0)
00187 #endif
00188 
00189 #ifdef STATISTICS
00190 extern int vpResampleCount;
00191 extern int vpCompositeCount;
00192 extern int vpERTSkipCount;
00193 extern int vpERTSkipAgainCount;
00194 extern int vpERTUpdateCount;
00195 extern int vpSpecialZeroSkipCount;
00196 extern int vpRunFragmentCount;
00197 #define COUNT_RESAMPLE          vpResampleCount++
00198 #define COUNT_COMPOSITE         vpCompositeCount++
00199 #define COUNT_ERT_SKIP          vpERTSkipCount++
00200 #define COUNT_ERT_SKIP_AGAIN    vpERTSkipAgainCount++
00201 #define COUNT_ERT_UPDATE        vpERTUpdateCount++
00202 #define COUNT_SPECIAL_ZERO_SKIP vpSpecialZeroSkipCount++
00203 #define COUNT_RUN_FRAGMENT      vpRunFragmentCount++
00204 #else
00205 #define COUNT_RESAMPLE
00206 #define COUNT_COMPOSITE
00207 #define COUNT_ERT_SKIP
00208 #define COUNT_ERT_SKIP_AGAIN
00209 #define COUNT_ERT_UPDATE
00210 #define COUNT_SPECIAL_ZERO_SKIP
00211 #define COUNT_RUN_FRAGMENT
00212 #endif /* STATISTICS */
00213 
00214 /*
00215  * VPCompAR1PB
00216  *
00217  * Compositing routine for run-length encoded volume data slices.
00218  * Decode and resample one slice of volume data, and composite
00219  * it into the intermediate image.  The resampling filter is a bilirp.
00220  */
00221 
00222 void
00223 VPCompAR1PB (vpc, icount, jcount, k, slice_depth_cueing_dbl, intimage,
00224           weightTLdbl, weightBLdbl, weightTRdbl, weightBRdbl,
00225           voxel_data, voxel_istride, voxel_jstride )
00226 vpContext *vpc;                 /* context */
00227 int icount;                     /* slice size */
00228 int jcount;
00229 int k;                          /* slice number */
00230 double slice_depth_cueing_dbl;  /* depth cueing factor for slice */
00231 GrayIntPixel *intimage;         /* intermediate image pixels */
00232 double weightTLdbl;             /* resampling weights */
00233 double weightBLdbl;
00234 double weightTRdbl;
00235 double weightBRdbl;
00236 
00237                 void *voxel_data;               /* voxel data for slice */
00238                 int voxel_istride;              /* strides for voxel data */
00239                 int voxel_jstride;
00240 
00241 {
00242     int i, j;                   /* voxel index in rotated object space */
00243     GrayIntPixel *ipixel;       /* current intermediate image pixel */
00244     GrayIntPixel *ipixel2;      /* another intermediate image pixel */
00245     int update_interval;        /* # of pixels to skip when updating links */
00246     float iopc;                 /* intermediate pixel opacity (0-1) */
00247     float iopc_inv;             /* 1-iopc */
00248     float acc_opc;              /* accumulator for resampled voxel opacity */
00249     float top_opc, bot_opc;     /* voxel opacity (top and bottom scanlines) */
00250 #ifdef NO_REUSE_VOXEL
00251 #define voxels_loaded   0
00252 #define CLEAR_VOXELS_LOADED
00253 #define SET_VOXELS_LOADED
00254 #else
00255     int voxels_loaded;          /* if true, top/bot_opc contain valid
00256                                    data loaded during the last resample */
00257 #define CLEAR_VOXELS_LOADED     voxels_loaded = 0
00258 #define SET_VOXELS_LOADED       voxels_loaded = 1
00259 #endif
00260     float wgtTL, wgtBL,         /* weights in the range 0..1 which give the */
00261           wgtTR, wgtBR;         /*   fractional contribution of the */
00262                                 /*   neighboring voxels to the current */
00263                                 /*   intermediate image pixel */
00264     unsigned char *topRLElen;   /* length of current run in top scanline */
00265     unsigned char *botRLElen;   /* length of current run in bottom scanline */
00266     char *topRLEdata;           /* data for current run in top scanline */
00267     char *botRLEdata;           /* data for current run in bottom scanline */
00268     int toprun_count;           /* number of voxels left in top run */
00269     int botrun_count;           /* number of voxels left in bottom run */
00270     int last_run_state;         /* run state code for last resample */
00271     int run_state;              /* run state code for this resample */
00272     int final_run_state;        /* run state code for end of scanline */
00273     float min_opacity;          /* low opacity threshold */
00274     float max_opacity;          /* high opacity threshold */
00275     float slice_depth_cueing;   /* depth cueing factor for slice */
00276     float *opac_correct;        /* opacity correction table */
00277     int ert_skip_count;         /* number of pixels to skip for ERT */
00278     int intermediate_width;     /* width of intermediate image in pixels */
00279     int count;                  /* voxels left in current run */
00280     float *shade_table;         /* shade lookup table */
00281     int norm_offset;            /* byte offset to shade table index in voxel */
00282     int shade_index;            /* shade index */
00283     float shade_factor;         /* attenuation factor for color
00284                                    (voxel opacity * depth cueing) */
00285 
00286 #ifdef MULTIPLE_MATERIALS
00287     float *weight_table;        /* weight lookup table */
00288     int wgt_offset;             /* byte offset to weight table index */
00289     int weight_index;           /* weight index */
00290     int m, num_materials;
00291     float weight1, weight2;
00292 #endif /* MULTIPLE_MATERIALS */
00293 
00294 #ifdef GRAYSCALE
00295     float acc_clr;              /* accumulator for resampled color */
00296     float top_clr, bot_clr;     /* voxel color (top and bottom scanlines) */
00297 #endif /* GRAYSCALE */
00298 
00299 #ifdef RGB
00300     float acc_rclr;             /* accumulator for resampled color */
00301     float acc_gclr;
00302     float acc_bclr;
00303     float top_rclr;             /* voxel color (top and bottom scanlines) */
00304     float bot_rclr;
00305     float top_gclr;
00306     float bot_gclr;
00307     float top_bclr;
00308     float bot_bclr;
00309 #endif
00310 
00311 #ifdef RLEVOLUME
00312     int voxel_istride;          /* size of a voxel in bytes */
00313 #endif
00314 
00315 #ifdef RAWVOLUME
00316     int use_octree;             /* if true then use the min-max octree */
00317     MMOctreeLevel level_stack[VP_MAX_OCTREE_LEVELS];
00318                                 /* stack for traversal of min-max octree */
00319     int scans_left;             /* scanlines until next octree traversal */
00320     int best_view_axis;         /* viewing axis */
00321     unsigned char runlen_buf1[VP_MAX_VOLUME_DIM]; /* buffers for run lengths */
00322     unsigned char runlen_buf2[VP_MAX_VOLUME_DIM];
00323     unsigned char *top_len_base;/* first run length for top scanline */
00324     unsigned char *bot_len_base;/* first run length for bottom scanline */
00325     int opac_param;             /* parameter to opacity transfer function */
00326     float opacity;              /* voxel opacity */
00327     int opacity_int;            /* voxel opacity truncated to an integer */
00328     int param0_offset;          /* offset to first parameter in voxel */
00329     int param0_size;            /* size of first parameter in bytes */
00330     float *param0_table;        /* lookup table for first parameter */
00331     int param1_offset;          /* offset to second parameter in voxel */
00332     int param1_size;            /* size of second parameter in bytes */
00333     float *param1_table;        /* lookup table for second parameter */
00334     int param2_offset;          /* offset to third parameter in voxel */
00335     int param2_size;            /* size of third parameter in bytes */
00336     float *param2_table;        /* lookup table for third parameter */
00337 #endif /* RAWVOLUME */
00338 
00339 #ifdef INDEX_VOLUME
00340     unsigned char *scanline_topRLElen; /* first topRLElen in scanline */
00341     unsigned char *scanline_botRLElen; /* first botRLElen in scanline */
00342     char *scanline_topRLEdata;  /* first topRLEdata in scanline */
00343     char *scanline_botRLEdata;  /* first botRLEdata in scanline */
00344     VoxelLocation *top_voxel_index; /* voxel indexes for top scanline */
00345     VoxelLocation *bot_voxel_index; /* voxel indexes for bot scanline */
00346     VoxelLocation *vindex;
00347     int next_i;                 /* i coordinate of voxel to skip to */
00348     int next_scan;              /* true if skipped to next scanline */
00349 #endif /* INDEX_VOLUME */
00350 
00351 #ifdef CALLBACK
00352                                 /* shading callback function */
00353 #ifdef GRAYSCALE
00354     void (*shade_func) ANSI_ARGS((void *, float *, void *));
00355 #endif
00356 #ifdef RGB
00357     void (*shade_func) ANSI_ARGS((void *, float *, float *, float *, void *));
00358 #endif
00359     void *client_data;          /* client data handle */
00360 #endif /* CALLBACK */
00361 
00362 #ifdef USE_SHADOW_BUFFER
00363     float *shadow_table;        /* color lookup table for shadows */
00364     int shadow_width;           /* width of shadow buffer */
00365     GrayIntPixel *shadow_pixel; /* current shadow buffer pixel */
00366 #ifdef GRAYSCALE
00367     float top_sclr, bot_sclr;   /* shadow color (top and bottom scanlines) */
00368 #endif /* GRAYSCALE */
00369 #ifdef RGB
00370     float top_rsclr;            /* shadow color (top and bottom scanlines) */
00371     float bot_rsclr;
00372     float top_gsclr;
00373     float bot_gsclr;
00374     float top_bsclr;
00375     float bot_bsclr;
00376 #endif
00377 #endif /* SHADOW_BUFFER */
00378 
00379 #ifdef DEBUG
00380     float trace_opcTL, trace_opcBL, trace_opcTR, trace_opcBR;
00381     float trace_rsclrTL, trace_rsclrBL, trace_rsclrTR, trace_rsclrBR;
00382     float trace_rclrTL, trace_rclrBL, trace_rclrTR, trace_rclrBR;
00383     float trace_gclrTL, trace_gclrBL, trace_gclrTR, trace_gclrBR;
00384     float trace_bclrTL, trace_bclrBL, trace_bclrTR, trace_bclrBR;
00385     GrayIntPixel *trace_pixel_ptr;
00386 
00387 #ifdef COMPUTE_SHADOW_BUFFER
00388     int slice_u_int, shadow_slice_u_int;
00389     int slice_v_int, shadow_slice_v_int;
00390 #endif
00391 #endif /* DEBUG */
00392 
00393     DECLARE_HIRES_TIME(t0);
00394     DECLARE_HIRES_TIME(t1);
00395 
00396     /*******************************************************************
00397      * Copy parameters from the rendering context into local variables.
00398      *******************************************************************/
00399 
00400     GET_HIRES_TIME(vpc, t0);
00401 
00402     wgtTL = weightTLdbl;
00403     wgtBL = weightBLdbl;
00404     wgtTR = weightTRdbl;
00405     wgtBR = weightBRdbl;
00406     slice_depth_cueing = slice_depth_cueing_dbl;
00407     min_opacity = vpc->min_opacity;
00408     max_opacity = vpc->max_opacity;
00409 #ifdef USE_SHADOW_BUFFER
00410     opac_correct = vpc->shadow_opac_correct;
00411 #else
00412     opac_correct = vpc->affine_opac_correct;
00413 #endif
00414 #ifdef COMPUTE_SHADOW_BUFFER
00415     intermediate_width = vpc->shadow_width;
00416 #else
00417     intermediate_width = vpc->intermediate_width;
00418 #endif
00419 #ifdef USE_SHADOW_BUFFER
00420     shadow_table = vpc->shadow_color_table;
00421     shadow_width = vpc->shadow_width;
00422     shadow_pixel = shadow_buffer;
00423 #endif
00424     ipixel = intimage;
00425     shade_table = vpc->shade_color_table;
00426     norm_offset = vpc->field_offset[vpc->color_field];
00427 
00428 #ifdef MULTIPLE_MATERIALS
00429     weight_table = vpc->shade_weight_table;
00430     wgt_offset = vpc->field_offset[vpc->weight_field];
00431     num_materials = vpc->num_materials;
00432 #endif /* MULTIPLE_MATERIALS */
00433 
00434 #ifdef RLEVOLUME
00435     topRLEdata = voxel_data;
00436     botRLEdata = voxel_data;
00437     topRLElen = run_lengths;
00438     botRLElen = run_lengths;
00439     voxel_istride = vpc->rle_bytes_per_voxel;
00440 #endif /* RLEVOLUME */
00441 
00442 #ifdef RAWVOLUME
00443     ASSERT(vpc->num_clsfy_params > 0);
00444     ASSERT(vpc->num_clsfy_params < 3);
00445     param0_offset = vpc->field_offset[vpc->param_field[0]];
00446     param0_size = vpc->field_size[vpc->param_field[0]];
00447     param0_table = vpc->clsfy_table[0];
00448     if (vpc->num_clsfy_params > 1) {
00449         param1_offset = vpc->field_offset[vpc->param_field[1]];
00450         param1_size = vpc->field_size[vpc->param_field[1]];
00451         param1_table = vpc->clsfy_table[1];
00452     } else {
00453         param1_offset = 0;
00454         param1_size = 0;
00455         param1_table = NULL;
00456     }
00457     if (vpc->num_clsfy_params > 2) {
00458         param2_offset = vpc->field_offset[vpc->param_field[2]];
00459         param2_size = vpc->field_size[vpc->param_field[2]];
00460         param2_table = vpc->clsfy_table[2];
00461     } else {
00462         param2_offset = 0;
00463         param2_size = 0;
00464         param2_table = NULL;
00465     }
00466     if (vpc->mm_octree == NULL) {
00467         use_octree = 0;
00468     } else {
00469         use_octree = 1;
00470         best_view_axis = vpc->best_view_axis;
00471         VPInitOctreeLevelStack(vpc, level_stack, best_view_axis, k);
00472         scans_left = 0;
00473         bot_len_base = runlen_buf1;
00474     }
00475 #endif /* RAWVOLUME */
00476 
00477 #ifdef CALLBACK
00478     shade_func = vpc->shade_func;
00479     client_data = vpc->client_data;
00480     ASSERT(shade_func != NULL);
00481 #endif
00482 
00483 #ifdef DEBUG
00484     trace_pixel_ptr = 0;
00485     if (vpc->trace_u >= 0 && vpc->trace_v >= 0) {
00486 #ifdef GRAYSCALE
00487         trace_pixel_ptr = &vpc->int_image.gray_intim[vpc->trace_u + 
00488                       vpc->trace_v*vpc->intermediate_width];
00489 #endif
00490 #ifdef RGB
00491         trace_pixel_ptr = &vpc->int_image.rgb_intim[vpc->trace_u + 
00492                       vpc->trace_v*vpc->intermediate_width];
00493 #endif
00494 #ifdef COMPUTE_SHADOW_BUFFER
00495         slice_u_int = (int)ceil(vpc->shear_i * vpc->trace_shadow_k +
00496                                 vpc->trans_i) - 1;
00497         shadow_slice_u_int = (int)ceil(vpc->shadow_shear_i * 
00498                              vpc->trace_shadow_k + vpc->shadow_trans_i) - 1;
00499         slice_v_int = (int)ceil(vpc->shear_j * vpc->trace_shadow_k
00500                                 + vpc->trans_j) - 1;
00501         shadow_slice_v_int = (int)ceil(vpc->shadow_shear_j *
00502                              vpc->trace_shadow_k + vpc->shadow_trans_j) - 1;
00503         trace_pixel_ptr = &vpc->shadow_buffer[vpc->trace_u +
00504                 shadow_slice_u_int - slice_u_int + 
00505                 (vpc->trace_v + shadow_slice_v_int -
00506                 slice_v_int)*vpc->shadow_width];
00507 #endif
00508     }
00509 #endif /* DEBUG */
00510 
00511     /*******************************************************************
00512      * Loop over voxel scanlines.
00513      *******************************************************************/
00514 
00515     for (j = 0; j <= jcount; j++) {
00516 
00517         /***************************************************************
00518          * Initialize counters and flags.
00519          ***************************************************************/
00520 
00521         i = icount;
00522         CLEAR_VOXELS_LOADED;
00523         last_run_state = ALL_ZERO;
00524 
00525 #ifdef RAWVOLUME
00526         botRLEdata = (char *)voxel_data + j*voxel_jstride;
00527         topRLEdata = botRLEdata - voxel_jstride;
00528         if (!use_octree) {
00529             if (j == 0) {
00530                 run_state = BOT_NONZERO;
00531                 toprun_count = icount+2;
00532                 botrun_count = icount;
00533             } else if (j == jcount) {
00534                 run_state = TOP_NONZERO;
00535                 toprun_count = icount;
00536                 botrun_count = icount+2;
00537             } else {
00538                 run_state = ALL_NONZERO;
00539                 toprun_count = icount;
00540                 botrun_count = icount;
00541             }
00542         } else
00543 #endif /* RAWVOLUME */
00544         if (j == 0) {
00545             run_state = BOT_NONZERO;
00546             toprun_count = icount+2;
00547             botrun_count = 0;
00548         } else if (j == jcount) {
00549             run_state = TOP_NONZERO;
00550             toprun_count = 0;
00551             botrun_count = icount+2;
00552         } else {
00553             run_state = ALL_NONZERO;
00554             toprun_count = 0;
00555             botrun_count = 0;
00556         }
00557 
00558 #ifdef INDEX_VOLUME
00559         scanline_topRLElen = topRLElen;
00560         scanline_botRLElen = botRLElen;
00561         scanline_topRLEdata = topRLEdata;
00562         scanline_botRLEdata = botRLEdata;
00563         if (j == 0) {
00564             top_voxel_index = voxel_index;
00565             bot_voxel_index = voxel_index;
00566         } else {
00567             top_voxel_index = bot_voxel_index;
00568             bot_voxel_index += icount;
00569         }
00570 #endif /* INDEX_VOLUME */
00571 
00572         /***************************************************************
00573          * If the volume is not run-length encoded, use the min-max
00574          * to find run lengths for the current voxel scanline.
00575          ***************************************************************/
00576 
00577 #ifdef RAWVOLUME
00578         if (use_octree) {
00579             top_len_base = bot_len_base;
00580             if (scans_left == 0) {
00581                 if (bot_len_base == runlen_buf1)
00582                     bot_len_base = runlen_buf2;
00583                 else
00584                     bot_len_base = runlen_buf1;
00585 
00586                 GET_HIRES_TIME(vpc, t1);
00587                 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
00588                 COPY_HIRES_TIME(t0, t1);
00589 
00590                 scans_left = VPComputeScanRuns(vpc, level_stack, bot_len_base,
00591                                                best_view_axis, j, icount);
00592 
00593                 GET_HIRES_TIME(vpc, t1);
00594                 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_OCTREE, t0, t1);
00595                 COPY_HIRES_TIME(t0, t1);
00596             }
00597 #ifdef DEBUG
00598             if (j > 0)
00599                 VPCheckRuns(vpc, top_len_base, best_view_axis, k, j-1);
00600             if (j < jcount)
00601                 VPCheckRuns(vpc, bot_len_base, best_view_axis, k, j);
00602 #endif
00603             scans_left--;
00604             topRLElen = top_len_base;
00605             botRLElen = bot_len_base;
00606         }
00607 #endif /* RAWVOLUME */
00608 
00609         /***************************************************************
00610          * Loop over runs in the voxel scanline.
00611          ***************************************************************/
00612 
00613         Debug((vpc, VPDEBUG_COMPOSITE, "StartIScan(u=%d,v=%d)\n",
00614                (((int)ipixel - (int)vpc->int_image.gray_intim) /
00615                 sizeof(GrayIntPixel)) % vpc->intermediate_width,
00616                (((int)ipixel - (int)vpc->int_image.gray_intim) /
00617                 sizeof(GrayIntPixel)) / vpc->intermediate_width));
00618 
00619 #ifdef UNROLL_RUN_LOOP
00620         while (i > 0) {
00621 #else
00622         while (i >= 0) {
00623 #endif
00624             /***********************************************************
00625              * Skip over any empty runs at beginning of scanline.
00626              ***********************************************************/
00627 
00628             if (last_run_state == ALL_ZERO) {
00629 #ifndef UNROLL_RUN_LOOP
00630                 if (i == 0) {
00631                     Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
00632                     ipixel += 1;
00633                     final_run_state = ALL_ZERO;
00634                     i = -1;
00635                     break;      /* scanline is done */
00636                 }
00637 #endif
00638 
00639                 /* check if this is the start of a new run */
00640                 while (toprun_count == 0) {
00641                     toprun_count = *topRLElen++;
00642                     run_state ^= 1;
00643                 }
00644                 while (botrun_count == 0) {
00645                     botrun_count = *botRLElen++;
00646                     run_state ^= 2;
00647                 }
00648                 if (run_state == ALL_ZERO) {
00649                     COUNT_SPECIAL_ZERO_SKIP;
00650 
00651                     /* find the union of the two runs of voxels */
00652                     count = MIN(toprun_count, botrun_count);
00653                     toprun_count -= count;
00654                     botrun_count -= count;
00655                     ipixel += count;
00656                     topRLEdata += count * voxel_istride;
00657                     botRLEdata += count * voxel_istride;
00658                     i -= count;
00659                     ASSERT(i >= 0);
00660                     Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(%d)\n", count));
00661                     continue;
00662                 }
00663             }
00664 
00665 #ifndef SKIP_ERT
00666             /***********************************************************
00667              * Skip over opaque pixels (early-ray termination).
00668              ***********************************************************/
00669 
00670             if ((ert_skip_count = ipixel->lnk) != 0) {
00671 
00672                 GET_HIRES_TIME(vpc, t1);
00673                 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
00674                 COPY_HIRES_TIME(t0, t1);
00675 
00676                 COUNT_ERT_SKIP;
00677 
00678 #ifndef UNROLL_RUN_LOOP
00679                 if (i == 0) {
00680                     ipixel += 1;
00681                     final_run_state = last_run_state;
00682                     i = -1;
00683                     Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
00684                     break;      /* scanline is done */
00685                 }
00686 #endif
00687 
00688                 /* find out how many pixels to skip */
00689                 if (ert_skip_count < i &&
00690                                 (count = ipixel[ert_skip_count].lnk) != 0) {
00691                     /* follow pointer chain */
00692                     do {
00693                         COUNT_ERT_SKIP_AGAIN;
00694                         ert_skip_count += count;
00695                     } while (ert_skip_count < i &&
00696                                  (count = ipixel[ert_skip_count].lnk) != 0);
00697 
00698                     /* update some of the lnk pointers in the run of opaque
00699                        pixels; the more links we update the longer it will
00700                        take to perform the update, but we will potentially
00701                        save time in future slices by not having to follow
00702                        long pointer chains */
00703                     ipixel2 = ipixel;
00704                     update_interval = 1;
00705                     count = ert_skip_count - 1;
00706                     while (count > 0) {
00707                         COUNT_ERT_UPDATE;
00708                         ipixel2 += update_interval;
00709                         if (count > 255)
00710                             ipixel2->lnk = 255;
00711                         else
00712                             ipixel2->lnk = count;
00713                         update_interval *= 2;
00714                         count -= update_interval;
00715                     }
00716 
00717                     /* update the current link */
00718                     COUNT_ERT_UPDATE;
00719                     if (ert_skip_count > 255)
00720                         ert_skip_count = 255;
00721                     ipixel->lnk = ert_skip_count;
00722                 }
00723 
00724                 /* skip over the opaque pixels */
00725                 if (ert_skip_count > i)
00726                     ert_skip_count = i;
00727                 Debug((vpc, VPDEBUG_COMPOSITE,"ERTSkip(%d)\n",ert_skip_count));
00728                 ipixel += ert_skip_count;
00729                 CLEAR_VOXELS_LOADED;
00730 
00731 #ifdef INDEX_VOLUME
00732                 /* compute i coordinate of voxel to skip to */
00733                 next_i = icount - i + ert_skip_count;
00734                 if (next_i == icount) {
00735                     next_i--;
00736                     next_scan = 1;
00737                 } else {
00738                     next_scan = 0;
00739                 }
00740 
00741                 /* skip over voxels in top scanline */
00742                 vindex = &top_voxel_index[next_i];
00743                 toprun_count = vindex->run_count;
00744                 topRLElen = scanline_topRLElen + vindex->len_offset;
00745                 if (vindex->data_offset & INDEX_RUN_IS_ZERO) {
00746                     run_state &= ~1;
00747                     topRLEdata = scanline_topRLEdata +
00748                         (vindex->data_offset & ~INDEX_RUN_IS_ZERO);
00749                 } else {
00750                     run_state |= 1;
00751                     topRLEdata = scanline_topRLEdata + vindex->data_offset;
00752                 }
00753 
00754                 /* skip over voxels in bottom scanline */
00755                 vindex = &bot_voxel_index[next_i];
00756                 botrun_count = vindex->run_count;
00757                 botRLElen = scanline_botRLElen + vindex->len_offset;
00758                 if (vindex->data_offset & INDEX_RUN_IS_ZERO) {
00759                     run_state &= ~2;
00760                     botRLEdata = scanline_botRLEdata +
00761                         (vindex->data_offset & ~INDEX_RUN_IS_ZERO);
00762                 } else {
00763                     run_state |= 2;
00764                     botRLEdata = scanline_botRLEdata + vindex->data_offset;
00765                 }
00766 
00767                 /* special case to skip over last voxel in scanline */
00768                 if (next_scan) {
00769                     /* advance to beginning of next top scanline */
00770                     while (toprun_count == 0) {
00771                         toprun_count = *topRLElen++;
00772                         run_state ^= 1;
00773                     }
00774                     toprun_count--;
00775                     if (run_state & 1) {
00776                         topRLEdata += 1 * voxel_istride;
00777                     } else {
00778                         topRLEdata += 1 * voxel_istride;
00779                     }
00780 
00781                     /* advance to beginning of next bottom scanline */
00782                     while (botrun_count == 0) {
00783                         botrun_count = *botRLElen++;
00784                         run_state ^= 2;
00785                     }
00786                     botrun_count--;
00787                     if (run_state & 2) {
00788                         botRLEdata += 1 * voxel_istride;
00789                     } else {
00790                         botRLEdata += 1 * voxel_istride;
00791                     }
00792                 }
00793 
00794 #else /* !INDEX_VOLUME */
00795                 /* skip over voxels in top scanline */
00796                 count = ert_skip_count;
00797                 for (;;) {
00798                     if (toprun_count >= count) {
00799                         toprun_count -= count;
00800                         if (run_state & 1) {
00801                             topRLEdata += count * voxel_istride;
00802                         } else {
00803                             topRLEdata += count * voxel_istride;
00804                         }
00805                         break;
00806                     } else {
00807                         count -= toprun_count;
00808                         if (run_state & 1) {
00809                             topRLEdata += toprun_count * voxel_istride;
00810                         } else {
00811                             topRLEdata += toprun_count * voxel_istride;
00812                         }
00813                         toprun_count = *topRLElen++;
00814                         if (toprun_count == 0)
00815                             toprun_count = *topRLElen++;
00816                         else
00817                             run_state ^= 1;
00818                     }
00819                 }
00820 
00821                 /* skip over voxels in bottom scanline */
00822                 count = ert_skip_count;
00823                 for (;;) {
00824                     if (botrun_count >= count) {
00825                         botrun_count -= count;
00826                         if (run_state & 2) {
00827                             botRLEdata += count * voxel_istride;
00828                         } else {
00829                             botRLEdata += count * voxel_istride;
00830                         }
00831                         break;
00832                     } else {
00833                         count -= botrun_count;
00834                         if (run_state & 2) {
00835                             botRLEdata += botrun_count * voxel_istride;
00836                         } else {
00837                             botRLEdata += botrun_count * voxel_istride;
00838                         }
00839                         botrun_count = *botRLElen++;
00840                         if (botrun_count == 0)
00841                             botrun_count = *botRLElen++;
00842                         else
00843                             run_state ^= 2;
00844                     }
00845                 }
00846 #endif /* INDEX_VOLUME */
00847                 i -= ert_skip_count;
00848                 last_run_state = run_state;
00849                 if (i == 0) {
00850 #ifdef UNROLL_RUN_LOOP
00851                     break;
00852 #else
00853                     if (last_run_state == ALL_ZERO) {
00854                         ipixel += 1;
00855                         final_run_state = ALL_ZERO;
00856                         i = -1;
00857                         Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
00858                         break;  /* scanline is done */
00859                     }
00860                     if (ipixel->lnk != 0) {
00861                         ipixel += 1;
00862                         final_run_state = last_run_state;
00863                         i = -1;
00864                         Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
00865                         break;  /* scanline is done */
00866                     }
00867 #endif /* UNROLL_RUN_LOOP */
00868                 }
00869 
00870                 GET_HIRES_TIME(vpc, t1);
00871                 STORE_HIRES_TIME(vpc, VPTIMER_ERT, t0, t1);
00872                 COPY_HIRES_TIME(t0, t1);
00873             }
00874             ASSERT(ipixel->opcflt < max_opacity);
00875 #endif /* SKIP_ERT */
00876 
00877             /***********************************************************
00878              * Compute the length of the current run.
00879              ***********************************************************/
00880 
00881 #ifndef UNROLL_RUN_LOOP
00882             if (i == 0) {
00883                 final_run_state = last_run_state;
00884                 run_state = ALL_ZERO;
00885                 i = -1;
00886                 count = 1;
00887                 Debug((vpc, VPDEBUG_COMPOSITE, "Run(1)End\n"));
00888             } else {
00889 #endif
00890                 /* check if this is the start of a new run */
00891                 while (toprun_count == 0) {
00892                     toprun_count = *topRLElen++;
00893                     run_state ^= 1;
00894                 }
00895                 while (botrun_count == 0) {
00896                     botrun_count = *botRLElen++;
00897                     run_state ^= 2;
00898                 }
00899 
00900                 /* find the union of the two runs of voxels */
00901                 count = MIN(toprun_count, botrun_count);
00902                 toprun_count -= count;
00903                 botrun_count -= count;
00904                 i -= count;
00905                 Debug((vpc, VPDEBUG_COMPOSITE, "Run(%d)\n", count));
00906                 ASSERT(i >= 0);
00907 #ifndef UNROLL_RUN_LOOP
00908             }
00909 #endif
00910             COUNT_RUN_FRAGMENT;
00911 
00912             /***********************************************************
00913              * composite the voxels in the current run.
00914              ***********************************************************/
00915 
00916             GET_HIRES_TIME(vpc, t1);
00917             STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
00918             COPY_HIRES_TIME(t0, t1);
00919 
00920 #ifdef SKIP_COMPOSITE
00921             switch (run_state) {
00922             case ALL_ZERO:
00923                 ipixel += count;
00924                 topRLEdata += count * voxel_istride;
00925                 botRLEdata += count * voxel_istride;
00926                 count = 0;
00927                 break;
00928             case TOP_NONZERO:
00929                 ipixel += count;
00930                 topRLEdata += count * voxel_istride;
00931                 botRLEdata += count * voxel_istride;
00932                 count = 0;
00933                 break;
00934             case BOT_NONZERO:
00935                 ipixel += count;
00936                 topRLEdata += count * voxel_istride;
00937                 botRLEdata += count * voxel_istride;
00938                 count = 0;
00939                 break;
00940             case ALL_NONZERO:
00941                 ipixel += count;
00942                 topRLEdata += count * voxel_istride;
00943                 botRLEdata += count * voxel_istride;
00944                 count = 0;
00945                 break;
00946             }
00947 #else /* !SKIP_COMPOSITE */
00948 #ifdef UNROLL_RUN_LOOP
00949             /* this run contains pixels, so process them */
00950             switch ((last_run_state << 2) | run_state) {
00951             case ALL_ZERO__ALL_ZERO:
00952                 /* no voxels contribute to the pixels in this run */
00953                 ipixel += count;
00954                 topRLEdata += count * voxel_istride;
00955                 botRLEdata += count * voxel_istride;
00956                 count = 0;
00957                 break;
00958             case TOP_NONZERO__ALL_ZERO:
00959                 /* only the top-left voxel contributes to the first
00960                    pixel of the run, and the rest are zero */
00961                 if (!voxels_loaded) {
00962                     
00963     
00964             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
00965             opacity = param0_table[opac_param];
00966             if (param1_size != 0) {
00967                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
00968                 opacity *= param1_table[opac_param];
00969                 if (param2_size != 0) {
00970                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
00971                     opacity *= param2_table[opac_param];
00972                 }
00973             }
00974             if (opacity > min_opacity) {
00975                 opacity_int = opacity*255.;
00976                 top_opc = opac_correct[opacity_int];
00977             } else {
00978                 top_opc = (float)0.;
00979             };
00980     
00981     
00982     ;
00983     ;
00984     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
00985     shade_factor = top_opc * slice_depth_cueing;
00986     
00987         top_clr *= shade_factor;
00988     ;
00989                 }
00990                 
00991 #ifdef DEBUG
00992     if (ipixel == trace_pixel_ptr) {
00993         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
00994         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
00995         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
00996         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
00997         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
00998     }
00999 #endif
01000 ;
01001                 
01002        acc_opc = top_opc * wgtTL;
01003        acc_clr = top_clr * wgtTL;
01004        
01005 #ifdef DEBUG
01006     if (ipixel == trace_pixel_ptr) {
01007         trace_opcTL = top_opc;
01008         trace_rclrTL = top_clr;
01009         
01010     }
01011 #endif
01012 ;
01013                 
01014         COUNT_RESAMPLE;
01015         if (acc_opc > min_opacity) {
01016             COUNT_COMPOSITE;
01017             iopc = ipixel->opcflt;
01018 #           ifndef SKIP_ERT
01019                 ASSERT(iopc < max_opacity);
01020 #           endif
01021             iopc_inv = (float)1. - iopc;
01022             ipixel->clrflt += acc_clr * iopc_inv;
01023             iopc += acc_opc * iopc_inv;
01024             ipixel->opcflt = iopc;
01025             
01026 #ifdef DEBUG
01027     if (ipixel == trace_pixel_ptr) {
01028 #ifdef COMPUTE_SHADOW_BUFFER
01029         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01030 #else
01031         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01032 #endif
01033         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01034         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01035         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01036         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01037         printf("  %3.0f %3.0f\n", iopc*255., 
01038                ipixel->clrflt);
01039         
01040         
01041     }
01042 #endif /* DEBUG */
01043 ;
01044 #           ifndef SKIP_ERT
01045                 if (iopc >= max_opacity) {
01046                     ASSERT(ipixel->lnk == 0);
01047                     ipixel->lnk = 1;
01048                 }
01049 #           endif
01050         };
01051                 ipixel += count;
01052                 topRLEdata += count * voxel_istride;
01053                 botRLEdata += count * voxel_istride;
01054                 count = 0;
01055                 break;
01056             case BOT_NONZERO__ALL_ZERO:
01057                 /* only the bottom left voxel contributes to the first
01058                    pixel of the run, and the rest are zero */
01059                 if (!voxels_loaded) {
01060                     
01061     
01062             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01063             opacity = param0_table[opac_param];
01064             if (param1_size != 0) {
01065                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01066                 opacity *= param1_table[opac_param];
01067                 if (param2_size != 0) {
01068                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01069                     opacity *= param2_table[opac_param];
01070                 }
01071             }
01072             if (opacity > min_opacity) {
01073                 opacity_int = opacity*255.;
01074                 bot_opc = opac_correct[opacity_int];
01075             } else {
01076                 bot_opc = (float)0.;
01077             };
01078     
01079     
01080     ;
01081     ;
01082     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
01083     shade_factor = bot_opc * slice_depth_cueing;
01084     
01085         bot_clr *= shade_factor;
01086     ;
01087                 }
01088                 
01089 #ifdef DEBUG
01090     if (ipixel == trace_pixel_ptr) {
01091         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01092         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01093         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01094         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01095         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01096     }
01097 #endif
01098 ;
01099                 
01100        acc_opc = bot_opc * wgtBL;
01101        acc_clr = bot_clr * wgtBL;
01102        
01103 #ifdef DEBUG
01104     if (ipixel == trace_pixel_ptr) {
01105         trace_opcBL = bot_opc;
01106         trace_rclrBL = bot_clr;
01107         
01108     }
01109 #endif
01110 ;
01111                 
01112         COUNT_RESAMPLE;
01113         if (acc_opc > min_opacity) {
01114             COUNT_COMPOSITE;
01115             iopc = ipixel->opcflt;
01116 #           ifndef SKIP_ERT
01117                 ASSERT(iopc < max_opacity);
01118 #           endif
01119             iopc_inv = (float)1. - iopc;
01120             ipixel->clrflt += acc_clr * iopc_inv;
01121             iopc += acc_opc * iopc_inv;
01122             ipixel->opcflt = iopc;
01123             
01124 #ifdef DEBUG
01125     if (ipixel == trace_pixel_ptr) {
01126 #ifdef COMPUTE_SHADOW_BUFFER
01127         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01128 #else
01129         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01130 #endif
01131         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01132         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01133         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01134         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01135         printf("  %3.0f %3.0f\n", iopc*255., 
01136                ipixel->clrflt);
01137         
01138         
01139     }
01140 #endif /* DEBUG */
01141 ;
01142 #           ifndef SKIP_ERT
01143                 if (iopc >= max_opacity) {
01144                     ASSERT(ipixel->lnk == 0);
01145                     ipixel->lnk = 1;
01146                 }
01147 #           endif
01148         };
01149                 ipixel += count;
01150                 topRLEdata += count * voxel_istride;
01151                 botRLEdata += count * voxel_istride;
01152                 count = 0;
01153                 break;
01154             case ALL_NONZERO__ALL_ZERO:
01155                 /* the top and bottom left voxels contribute to the
01156                    first pixel of the run, and the rest are zero */
01157                 if (!voxels_loaded) {
01158                     
01159     
01160             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01161             opacity = param0_table[opac_param];
01162             if (param1_size != 0) {
01163                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01164                 opacity *= param1_table[opac_param];
01165                 if (param2_size != 0) {
01166                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01167                     opacity *= param2_table[opac_param];
01168                 }
01169             }
01170             if (opacity > min_opacity) {
01171                 opacity_int = opacity*255.;
01172                 top_opc = opac_correct[opacity_int];
01173             } else {
01174                 top_opc = (float)0.;
01175             };
01176     
01177     
01178     ;
01179     ;
01180     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
01181     shade_factor = top_opc * slice_depth_cueing;
01182     
01183         top_clr *= shade_factor;
01184     ;
01185                     
01186     
01187             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01188             opacity = param0_table[opac_param];
01189             if (param1_size != 0) {
01190                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01191                 opacity *= param1_table[opac_param];
01192                 if (param2_size != 0) {
01193                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01194                     opacity *= param2_table[opac_param];
01195                 }
01196             }
01197             if (opacity > min_opacity) {
01198                 opacity_int = opacity*255.;
01199                 bot_opc = opac_correct[opacity_int];
01200             } else {
01201                 bot_opc = (float)0.;
01202             };
01203     
01204     
01205     ;
01206     ;
01207     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
01208     shade_factor = bot_opc * slice_depth_cueing;
01209     
01210         bot_clr *= shade_factor;
01211     ;
01212                 }
01213                 
01214 #ifdef DEBUG
01215     if (ipixel == trace_pixel_ptr) {
01216         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01217         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01218         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01219         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01220         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01221     }
01222 #endif
01223 ;
01224                 
01225        acc_opc = top_opc * wgtTL;
01226        acc_clr = top_clr * wgtTL;
01227        
01228 #ifdef DEBUG
01229     if (ipixel == trace_pixel_ptr) {
01230         trace_opcTL = top_opc;
01231         trace_rclrTL = top_clr;
01232         
01233     }
01234 #endif
01235 ;
01236                 
01237        acc_opc += bot_opc * wgtBL;
01238        acc_clr += bot_clr * wgtBL;
01239        
01240 #ifdef DEBUG
01241     if (ipixel == trace_pixel_ptr) {
01242         trace_opcBL = bot_opc;
01243         trace_rclrBL = bot_clr;
01244         
01245     }
01246 #endif
01247 ;
01248                 
01249         COUNT_RESAMPLE;
01250         if (acc_opc > min_opacity) {
01251             COUNT_COMPOSITE;
01252             iopc = ipixel->opcflt;
01253 #           ifndef SKIP_ERT
01254                 ASSERT(iopc < max_opacity);
01255 #           endif
01256             iopc_inv = (float)1. - iopc;
01257             ipixel->clrflt += acc_clr * iopc_inv;
01258             iopc += acc_opc * iopc_inv;
01259             ipixel->opcflt = iopc;
01260             
01261 #ifdef DEBUG
01262     if (ipixel == trace_pixel_ptr) {
01263 #ifdef COMPUTE_SHADOW_BUFFER
01264         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01265 #else
01266         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01267 #endif
01268         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01269         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01270         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01271         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01272         printf("  %3.0f %3.0f\n", iopc*255., 
01273                ipixel->clrflt);
01274         
01275         
01276     }
01277 #endif /* DEBUG */
01278 ;
01279 #           ifndef SKIP_ERT
01280                 if (iopc >= max_opacity) {
01281                     ASSERT(ipixel->lnk == 0);
01282                     ipixel->lnk = 1;
01283                 }
01284 #           endif
01285         };
01286                 ipixel += count;
01287                 topRLEdata += count * voxel_istride;
01288                 botRLEdata += count * voxel_istride;
01289                 count = 0;
01290                 break;
01291             case ALL_ZERO__TOP_NONZERO:
01292                 /* first pixel: only the top-right voxel contributes */
01293                 
01294     
01295             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01296             opacity = param0_table[opac_param];
01297             if (param1_size != 0) {
01298                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01299                 opacity *= param1_table[opac_param];
01300                 if (param2_size != 0) {
01301                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01302                     opacity *= param2_table[opac_param];
01303                 }
01304             }
01305             if (opacity > min_opacity) {
01306                 opacity_int = opacity*255.;
01307                 top_opc = opac_correct[opacity_int];
01308             } else {
01309                 top_opc = (float)0.;
01310             };
01311     
01312     
01313     ;
01314     ;
01315     shade_func(topRLEdata, &(top_clr), client_data);
01316     shade_factor = top_opc * slice_depth_cueing;
01317     
01318         top_clr *= shade_factor;
01319     ;
01320                 
01321 #ifdef DEBUG
01322     if (ipixel == trace_pixel_ptr) {
01323         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01324         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01325         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01326         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01327         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01328     }
01329 #endif
01330 ;
01331                 
01332        acc_opc = top_opc * wgtTR;
01333        acc_clr = top_clr * wgtTR;
01334        
01335 #ifdef DEBUG
01336     if (ipixel == trace_pixel_ptr) {
01337         trace_opcTR = top_opc;
01338         trace_rclrTR = top_clr;
01339         
01340     }
01341 #endif
01342 ;
01343                 
01344         COUNT_RESAMPLE;
01345         if (acc_opc > min_opacity) {
01346             COUNT_COMPOSITE;
01347             iopc = ipixel->opcflt;
01348 #           ifndef SKIP_ERT
01349                 ASSERT(iopc < max_opacity);
01350 #           endif
01351             iopc_inv = (float)1. - iopc;
01352             ipixel->clrflt += acc_clr * iopc_inv;
01353             iopc += acc_opc * iopc_inv;
01354             ipixel->opcflt = iopc;
01355             
01356 #ifdef DEBUG
01357     if (ipixel == trace_pixel_ptr) {
01358 #ifdef COMPUTE_SHADOW_BUFFER
01359         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01360 #else
01361         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01362 #endif
01363         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01364         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01365         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01366         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01367         printf("  %3.0f %3.0f\n", iopc*255., 
01368                ipixel->clrflt);
01369         
01370         
01371     }
01372 #endif /* DEBUG */
01373 ;
01374 #           ifndef SKIP_ERT
01375                 if (iopc >= max_opacity) {
01376                     ASSERT(ipixel->lnk == 0);
01377                     ipixel->lnk = 1;
01378                 }
01379 #           endif
01380         };
01381                 ipixel += 1;
01382                 topRLEdata += 1 * voxel_istride;
01383                 botRLEdata += 1 * voxel_istride;
01384                 count--;
01385                 SET_VOXELS_LOADED;
01386 
01387                 /* do the rest of the pixels in this run;
01388                    the top-left and top-right voxels contribute */
01389                 while (count > 0) {
01390                     if (PIXEL_IS_OPAQUE(ipixel))
01391                         break;
01392                     if (!voxels_loaded) {
01393                         
01394     
01395             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01396             opacity = param0_table[opac_param];
01397             if (param1_size != 0) {
01398                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01399                 opacity *= param1_table[opac_param];
01400                 if (param2_size != 0) {
01401                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01402                     opacity *= param2_table[opac_param];
01403                 }
01404             }
01405             if (opacity > min_opacity) {
01406                 opacity_int = opacity*255.;
01407                 top_opc = opac_correct[opacity_int];
01408             } else {
01409                 top_opc = (float)0.;
01410             };
01411     
01412     
01413     ;
01414     ;
01415     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
01416     shade_factor = top_opc * slice_depth_cueing;
01417     
01418         top_clr *= shade_factor;
01419     ;
01420                     }
01421                     
01422 #ifdef DEBUG
01423     if (ipixel == trace_pixel_ptr) {
01424         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01425         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01426         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01427         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01428         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01429     }
01430 #endif
01431 ;
01432                     
01433        acc_opc = top_opc * wgtTL;
01434        acc_clr = top_clr * wgtTL;
01435        
01436 #ifdef DEBUG
01437     if (ipixel == trace_pixel_ptr) {
01438         trace_opcTL = top_opc;
01439         trace_rclrTL = top_clr;
01440         
01441     }
01442 #endif
01443 ;
01444                     
01445     
01446             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01447             opacity = param0_table[opac_param];
01448             if (param1_size != 0) {
01449                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01450                 opacity *= param1_table[opac_param];
01451                 if (param2_size != 0) {
01452                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01453                     opacity *= param2_table[opac_param];
01454                 }
01455             }
01456             if (opacity > min_opacity) {
01457                 opacity_int = opacity*255.;
01458                 top_opc = opac_correct[opacity_int];
01459             } else {
01460                 top_opc = (float)0.;
01461             };
01462     
01463     
01464     ;
01465     ;
01466     shade_func(topRLEdata, &(top_clr), client_data);
01467     shade_factor = top_opc * slice_depth_cueing;
01468     
01469         top_clr *= shade_factor;
01470     ;
01471                     
01472        acc_opc += top_opc * wgtTR;
01473        acc_clr += top_clr * wgtTR;
01474        
01475 #ifdef DEBUG
01476     if (ipixel == trace_pixel_ptr) {
01477         trace_opcTR = top_opc;
01478         trace_rclrTR = top_clr;
01479         
01480     }
01481 #endif
01482 ;
01483                     
01484         COUNT_RESAMPLE;
01485         if (acc_opc > min_opacity) {
01486             COUNT_COMPOSITE;
01487             iopc = ipixel->opcflt;
01488 #           ifndef SKIP_ERT
01489                 ASSERT(iopc < max_opacity);
01490 #           endif
01491             iopc_inv = (float)1. - iopc;
01492             ipixel->clrflt += acc_clr * iopc_inv;
01493             iopc += acc_opc * iopc_inv;
01494             ipixel->opcflt = iopc;
01495             
01496 #ifdef DEBUG
01497     if (ipixel == trace_pixel_ptr) {
01498 #ifdef COMPUTE_SHADOW_BUFFER
01499         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01500 #else
01501         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01502 #endif
01503         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01504         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01505         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01506         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01507         printf("  %3.0f %3.0f\n", iopc*255., 
01508                ipixel->clrflt);
01509         
01510         
01511     }
01512 #endif /* DEBUG */
01513 ;
01514 #           ifndef SKIP_ERT
01515                 if (iopc >= max_opacity) {
01516                     ASSERT(ipixel->lnk == 0);
01517                     ipixel->lnk = 1;
01518                 }
01519 #           endif
01520         };
01521                     ipixel += 1;
01522                     topRLEdata += 1 * voxel_istride;
01523                     botRLEdata += 1 * voxel_istride;
01524                     count--;
01525                     SET_VOXELS_LOADED;
01526                 }
01527                 break;
01528             case TOP_NONZERO__TOP_NONZERO:
01529                 /* do the pixels in this run; the top-left and
01530                    top-right voxels contribute */
01531                 while (count > 0) {
01532                     if (PIXEL_IS_OPAQUE(ipixel))
01533                         break;
01534                     if (!voxels_loaded) {
01535                         
01536     
01537             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01538             opacity = param0_table[opac_param];
01539             if (param1_size != 0) {
01540                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01541                 opacity *= param1_table[opac_param];
01542                 if (param2_size != 0) {
01543                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01544                     opacity *= param2_table[opac_param];
01545                 }
01546             }
01547             if (opacity > min_opacity) {
01548                 opacity_int = opacity*255.;
01549                 top_opc = opac_correct[opacity_int];
01550             } else {
01551                 top_opc = (float)0.;
01552             };
01553     
01554     
01555     ;
01556     ;
01557     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
01558     shade_factor = top_opc * slice_depth_cueing;
01559     
01560         top_clr *= shade_factor;
01561     ;
01562                     }
01563                     
01564 #ifdef DEBUG
01565     if (ipixel == trace_pixel_ptr) {
01566         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01567         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01568         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01569         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01570         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01571     }
01572 #endif
01573 ;
01574                     
01575        acc_opc = top_opc * wgtTL;
01576        acc_clr = top_clr * wgtTL;
01577        
01578 #ifdef DEBUG
01579     if (ipixel == trace_pixel_ptr) {
01580         trace_opcTL = top_opc;
01581         trace_rclrTL = top_clr;
01582         
01583     }
01584 #endif
01585 ;
01586                     
01587     
01588             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01589             opacity = param0_table[opac_param];
01590             if (param1_size != 0) {
01591                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01592                 opacity *= param1_table[opac_param];
01593                 if (param2_size != 0) {
01594                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01595                     opacity *= param2_table[opac_param];
01596                 }
01597             }
01598             if (opacity > min_opacity) {
01599                 opacity_int = opacity*255.;
01600                 top_opc = opac_correct[opacity_int];
01601             } else {
01602                 top_opc = (float)0.;
01603             };
01604     
01605     
01606     ;
01607     ;
01608     shade_func(topRLEdata, &(top_clr), client_data);
01609     shade_factor = top_opc * slice_depth_cueing;
01610     
01611         top_clr *= shade_factor;
01612     ;
01613                     
01614        acc_opc += top_opc * wgtTR;
01615        acc_clr += top_clr * wgtTR;
01616        
01617 #ifdef DEBUG
01618     if (ipixel == trace_pixel_ptr) {
01619         trace_opcTR = top_opc;
01620         trace_rclrTR = top_clr;
01621         
01622     }
01623 #endif
01624 ;
01625                     
01626         COUNT_RESAMPLE;
01627         if (acc_opc > min_opacity) {
01628             COUNT_COMPOSITE;
01629             iopc = ipixel->opcflt;
01630 #           ifndef SKIP_ERT
01631                 ASSERT(iopc < max_opacity);
01632 #           endif
01633             iopc_inv = (float)1. - iopc;
01634             ipixel->clrflt += acc_clr * iopc_inv;
01635             iopc += acc_opc * iopc_inv;
01636             ipixel->opcflt = iopc;
01637             
01638 #ifdef DEBUG
01639     if (ipixel == trace_pixel_ptr) {
01640 #ifdef COMPUTE_SHADOW_BUFFER
01641         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01642 #else
01643         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01644 #endif
01645         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01646         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01647         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01648         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01649         printf("  %3.0f %3.0f\n", iopc*255., 
01650                ipixel->clrflt);
01651         
01652         
01653     }
01654 #endif /* DEBUG */
01655 ;
01656 #           ifndef SKIP_ERT
01657                 if (iopc >= max_opacity) {
01658                     ASSERT(ipixel->lnk == 0);
01659                     ipixel->lnk = 1;
01660                 }
01661 #           endif
01662         };
01663                     ipixel += 1;
01664                     topRLEdata += 1 * voxel_istride;
01665                     botRLEdata += 1 * voxel_istride;
01666                     count--;
01667                     SET_VOXELS_LOADED;
01668                 }
01669                 break;
01670             case BOT_NONZERO__TOP_NONZERO:
01671                 /* first pixel: bottom-left and top-right voxels
01672                    contribute */
01673                 if (!voxels_loaded) {
01674                     
01675     
01676             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01677             opacity = param0_table[opac_param];
01678             if (param1_size != 0) {
01679                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01680                 opacity *= param1_table[opac_param];
01681                 if (param2_size != 0) {
01682                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01683                     opacity *= param2_table[opac_param];
01684                 }
01685             }
01686             if (opacity > min_opacity) {
01687                 opacity_int = opacity*255.;
01688                 bot_opc = opac_correct[opacity_int];
01689             } else {
01690                 bot_opc = (float)0.;
01691             };
01692     
01693     
01694     ;
01695     ;
01696     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
01697     shade_factor = bot_opc * slice_depth_cueing;
01698     
01699         bot_clr *= shade_factor;
01700     ;
01701                 }
01702                 
01703 #ifdef DEBUG
01704     if (ipixel == trace_pixel_ptr) {
01705         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01706         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01707         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01708         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01709         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01710     }
01711 #endif
01712 ;
01713                 
01714        acc_opc = bot_opc * wgtBL;
01715        acc_clr = bot_clr * wgtBL;
01716        
01717 #ifdef DEBUG
01718     if (ipixel == trace_pixel_ptr) {
01719         trace_opcBL = bot_opc;
01720         trace_rclrBL = bot_clr;
01721         
01722     }
01723 #endif
01724 ;
01725                 
01726     
01727             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01728             opacity = param0_table[opac_param];
01729             if (param1_size != 0) {
01730                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01731                 opacity *= param1_table[opac_param];
01732                 if (param2_size != 0) {
01733                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01734                     opacity *= param2_table[opac_param];
01735                 }
01736             }
01737             if (opacity > min_opacity) {
01738                 opacity_int = opacity*255.;
01739                 top_opc = opac_correct[opacity_int];
01740             } else {
01741                 top_opc = (float)0.;
01742             };
01743     
01744     
01745     ;
01746     ;
01747     shade_func(topRLEdata, &(top_clr), client_data);
01748     shade_factor = top_opc * slice_depth_cueing;
01749     
01750         top_clr *= shade_factor;
01751     ;
01752                 
01753        acc_opc += top_opc * wgtTR;
01754        acc_clr += top_clr * wgtTR;
01755        
01756 #ifdef DEBUG
01757     if (ipixel == trace_pixel_ptr) {
01758         trace_opcTR = top_opc;
01759         trace_rclrTR = top_clr;
01760         
01761     }
01762 #endif
01763 ;
01764                 
01765         COUNT_RESAMPLE;
01766         if (acc_opc > min_opacity) {
01767             COUNT_COMPOSITE;
01768             iopc = ipixel->opcflt;
01769 #           ifndef SKIP_ERT
01770                 ASSERT(iopc < max_opacity);
01771 #           endif
01772             iopc_inv = (float)1. - iopc;
01773             ipixel->clrflt += acc_clr * iopc_inv;
01774             iopc += acc_opc * iopc_inv;
01775             ipixel->opcflt = iopc;
01776             
01777 #ifdef DEBUG
01778     if (ipixel == trace_pixel_ptr) {
01779 #ifdef COMPUTE_SHADOW_BUFFER
01780         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01781 #else
01782         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01783 #endif
01784         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01785         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01786         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01787         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01788         printf("  %3.0f %3.0f\n", iopc*255., 
01789                ipixel->clrflt);
01790         
01791         
01792     }
01793 #endif /* DEBUG */
01794 ;
01795 #           ifndef SKIP_ERT
01796                 if (iopc >= max_opacity) {
01797                     ASSERT(ipixel->lnk == 0);
01798                     ipixel->lnk = 1;
01799                 }
01800 #           endif
01801         };
01802                 ipixel += 1;
01803                 topRLEdata += 1 * voxel_istride;
01804                 botRLEdata += 1 * voxel_istride;
01805                 count--;
01806                 SET_VOXELS_LOADED;
01807 
01808                 /* do the rest of the pixels in this run;
01809                    the top-left and top-right voxels contribute */
01810                 while (count > 0) {
01811                     if (PIXEL_IS_OPAQUE(ipixel))
01812                         break;
01813                     if (!voxels_loaded) {
01814                         
01815     
01816             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01817             opacity = param0_table[opac_param];
01818             if (param1_size != 0) {
01819                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01820                 opacity *= param1_table[opac_param];
01821                 if (param2_size != 0) {
01822                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01823                     opacity *= param2_table[opac_param];
01824                 }
01825             }
01826             if (opacity > min_opacity) {
01827                 opacity_int = opacity*255.;
01828                 top_opc = opac_correct[opacity_int];
01829             } else {
01830                 top_opc = (float)0.;
01831             };
01832     
01833     
01834     ;
01835     ;
01836     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
01837     shade_factor = top_opc * slice_depth_cueing;
01838     
01839         top_clr *= shade_factor;
01840     ;
01841                     }
01842                     
01843 #ifdef DEBUG
01844     if (ipixel == trace_pixel_ptr) {
01845         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01846         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01847         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01848         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01849         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01850     }
01851 #endif
01852 ;
01853                     
01854        acc_opc = top_opc * wgtTL;
01855        acc_clr = top_clr * wgtTL;
01856        
01857 #ifdef DEBUG
01858     if (ipixel == trace_pixel_ptr) {
01859         trace_opcTL = top_opc;
01860         trace_rclrTL = top_clr;
01861         
01862     }
01863 #endif
01864 ;
01865                     
01866     
01867             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01868             opacity = param0_table[opac_param];
01869             if (param1_size != 0) {
01870                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01871                 opacity *= param1_table[opac_param];
01872                 if (param2_size != 0) {
01873                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01874                     opacity *= param2_table[opac_param];
01875                 }
01876             }
01877             if (opacity > min_opacity) {
01878                 opacity_int = opacity*255.;
01879                 top_opc = opac_correct[opacity_int];
01880             } else {
01881                 top_opc = (float)0.;
01882             };
01883     
01884     
01885     ;
01886     ;
01887     shade_func(topRLEdata, &(top_clr), client_data);
01888     shade_factor = top_opc * slice_depth_cueing;
01889     
01890         top_clr *= shade_factor;
01891     ;
01892                     
01893        acc_opc += top_opc * wgtTR;
01894        acc_clr += top_clr * wgtTR;
01895        
01896 #ifdef DEBUG
01897     if (ipixel == trace_pixel_ptr) {
01898         trace_opcTR = top_opc;
01899         trace_rclrTR = top_clr;
01900         
01901     }
01902 #endif
01903 ;
01904                     
01905         COUNT_RESAMPLE;
01906         if (acc_opc > min_opacity) {
01907             COUNT_COMPOSITE;
01908             iopc = ipixel->opcflt;
01909 #           ifndef SKIP_ERT
01910                 ASSERT(iopc < max_opacity);
01911 #           endif
01912             iopc_inv = (float)1. - iopc;
01913             ipixel->clrflt += acc_clr * iopc_inv;
01914             iopc += acc_opc * iopc_inv;
01915             ipixel->opcflt = iopc;
01916             
01917 #ifdef DEBUG
01918     if (ipixel == trace_pixel_ptr) {
01919 #ifdef COMPUTE_SHADOW_BUFFER
01920         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01921 #else
01922         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01923 #endif
01924         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01925         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01926         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01927         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01928         printf("  %3.0f %3.0f\n", iopc*255., 
01929                ipixel->clrflt);
01930         
01931         
01932     }
01933 #endif /* DEBUG */
01934 ;
01935 #           ifndef SKIP_ERT
01936                 if (iopc >= max_opacity) {
01937                     ASSERT(ipixel->lnk == 0);
01938                     ipixel->lnk = 1;
01939                 }
01940 #           endif
01941         };
01942                     ipixel += 1;
01943                     topRLEdata += 1 * voxel_istride;
01944                     botRLEdata += 1 * voxel_istride;
01945                     count--;
01946                     SET_VOXELS_LOADED;
01947                 }
01948                 break;
01949             case ALL_NONZERO__TOP_NONZERO:
01950                 /* first pixel: top-left, bottom-left and top-right voxels
01951                    contribute */
01952                 if (!voxels_loaded) {
01953                     
01954     
01955             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01956             opacity = param0_table[opac_param];
01957             if (param1_size != 0) {
01958                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01959                 opacity *= param1_table[opac_param];
01960                 if (param2_size != 0) {
01961                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01962                     opacity *= param2_table[opac_param];
01963                 }
01964             }
01965             if (opacity > min_opacity) {
01966                 opacity_int = opacity*255.;
01967                 top_opc = opac_correct[opacity_int];
01968             } else {
01969                 top_opc = (float)0.;
01970             };
01971     
01972     
01973     ;
01974     ;
01975     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
01976     shade_factor = top_opc * slice_depth_cueing;
01977     
01978         top_clr *= shade_factor;
01979     ;
01980                     
01981     
01982             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01983             opacity = param0_table[opac_param];
01984             if (param1_size != 0) {
01985                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01986                 opacity *= param1_table[opac_param];
01987                 if (param2_size != 0) {
01988                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01989                     opacity *= param2_table[opac_param];
01990                 }
01991             }
01992             if (opacity > min_opacity) {
01993                 opacity_int = opacity*255.;
01994                 bot_opc = opac_correct[opacity_int];
01995             } else {
01996                 bot_opc = (float)0.;
01997             };
01998     
01999     
02000     ;
02001     ;
02002     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
02003     shade_factor = bot_opc * slice_depth_cueing;
02004     
02005         bot_clr *= shade_factor;
02006     ;
02007                 }
02008                 
02009 #ifdef DEBUG
02010     if (ipixel == trace_pixel_ptr) {
02011         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02012         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02013         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02014         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02015         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02016     }
02017 #endif
02018 ;
02019                 
02020        acc_opc = top_opc * wgtTL;
02021        acc_clr = top_clr * wgtTL;
02022        
02023 #ifdef DEBUG
02024     if (ipixel == trace_pixel_ptr) {
02025         trace_opcTL = top_opc;
02026         trace_rclrTL = top_clr;
02027         
02028     }
02029 #endif
02030 ;
02031                 
02032        acc_opc += bot_opc * wgtBL;
02033        acc_clr += bot_clr * wgtBL;
02034        
02035 #ifdef DEBUG
02036     if (ipixel == trace_pixel_ptr) {
02037         trace_opcBL = bot_opc;
02038         trace_rclrBL = bot_clr;
02039         
02040     }
02041 #endif
02042 ;
02043                 
02044     
02045             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
02046             opacity = param0_table[opac_param];
02047             if (param1_size != 0) {
02048                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
02049                 opacity *= param1_table[opac_param];
02050                 if (param2_size != 0) {
02051                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
02052                     opacity *= param2_table[opac_param];
02053                 }
02054             }
02055             if (opacity > min_opacity) {
02056                 opacity_int = opacity*255.;
02057                 top_opc = opac_correct[opacity_int];
02058             } else {
02059                 top_opc = (float)0.;
02060             };
02061     
02062     
02063     ;
02064     ;
02065     shade_func(topRLEdata, &(top_clr), client_data);
02066     shade_factor = top_opc * slice_depth_cueing;
02067     
02068         top_clr *= shade_factor;
02069     ;
02070                 
02071        acc_opc += top_opc * wgtTR;
02072        acc_clr += top_clr * wgtTR;
02073        
02074 #ifdef DEBUG
02075     if (ipixel == trace_pixel_ptr) {
02076         trace_opcTR = top_opc;
02077         trace_rclrTR = top_clr;
02078         
02079     }
02080 #endif
02081 ;
02082                 
02083         COUNT_RESAMPLE;
02084         if (acc_opc > min_opacity) {
02085             COUNT_COMPOSITE;
02086             iopc = ipixel->opcflt;
02087 #           ifndef SKIP_ERT
02088                 ASSERT(iopc < max_opacity);
02089 #           endif
02090             iopc_inv = (float)1. - iopc;
02091             ipixel->clrflt += acc_clr * iopc_inv;
02092             iopc += acc_opc * iopc_inv;
02093             ipixel->opcflt = iopc;
02094             
02095 #ifdef DEBUG
02096     if (ipixel == trace_pixel_ptr) {
02097 #ifdef COMPUTE_SHADOW_BUFFER
02098         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02099 #else
02100         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02101 #endif
02102         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02103         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02104         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02105         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02106         printf("  %3.0f %3.0f\n", iopc*255., 
02107                ipixel->clrflt);
02108         
02109         
02110     }
02111 #endif /* DEBUG */
02112 ;
02113 #           ifndef SKIP_ERT
02114                 if (iopc >= max_opacity) {
02115                     ASSERT(ipixel->lnk == 0);
02116                     ipixel->lnk = 1;
02117                 }
02118 #           endif
02119         };
02120                 ipixel += 1;
02121                 topRLEdata += 1 * voxel_istride;
02122                 botRLEdata += 1 * voxel_istride;
02123                 count--;
02124                 SET_VOXELS_LOADED;
02125 
02126                 /* do the rest of the pixels in this run;
02127                    the top-left and top-right voxels contribute */
02128                 while (count > 0) {
02129                     if (PIXEL_IS_OPAQUE(ipixel))
02130                         break;
02131                     if (!voxels_loaded) {
02132                         
02133     
02134             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02135             opacity = param0_table[opac_param];
02136             if (param1_size != 0) {
02137                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02138                 opacity *= param1_table[opac_param];
02139                 if (param2_size != 0) {
02140                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02141                     opacity *= param2_table[opac_param];
02142                 }
02143             }
02144             if (opacity > min_opacity) {
02145                 opacity_int = opacity*255.;
02146                 top_opc = opac_correct[opacity_int];
02147             } else {
02148                 top_opc = (float)0.;
02149             };
02150     
02151     
02152     ;
02153     ;
02154     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
02155     shade_factor = top_opc * slice_depth_cueing;
02156     
02157         top_clr *= shade_factor;
02158     ;
02159                     }
02160                     
02161 #ifdef DEBUG
02162     if (ipixel == trace_pixel_ptr) {
02163         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02164         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02165         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02166         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02167         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02168     }
02169 #endif
02170 ;
02171                     
02172        acc_opc = top_opc * wgtTL;
02173        acc_clr = top_clr * wgtTL;
02174        
02175 #ifdef DEBUG
02176     if (ipixel == trace_pixel_ptr) {
02177         trace_opcTL = top_opc;
02178         trace_rclrTL = top_clr;
02179         
02180     }
02181 #endif
02182 ;
02183                     
02184     
02185             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
02186             opacity = param0_table[opac_param];
02187             if (param1_size != 0) {
02188                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
02189                 opacity *= param1_table[opac_param];
02190                 if (param2_size != 0) {
02191                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
02192                     opacity *= param2_table[opac_param];
02193                 }
02194             }
02195             if (opacity > min_opacity) {
02196                 opacity_int = opacity*255.;
02197                 top_opc = opac_correct[opacity_int];
02198             } else {
02199                 top_opc = (float)0.;
02200             };
02201     
02202     
02203     ;
02204     ;
02205     shade_func(topRLEdata, &(top_clr), client_data);
02206     shade_factor = top_opc * slice_depth_cueing;
02207     
02208         top_clr *= shade_factor;
02209     ;
02210                     
02211        acc_opc += top_opc * wgtTR;
02212        acc_clr += top_clr * wgtTR;
02213        
02214 #ifdef DEBUG
02215     if (ipixel == trace_pixel_ptr) {
02216         trace_opcTR = top_opc;
02217         trace_rclrTR = top_clr;
02218         
02219     }
02220 #endif
02221 ;
02222                     
02223         COUNT_RESAMPLE;
02224         if (acc_opc > min_opacity) {
02225             COUNT_COMPOSITE;
02226             iopc = ipixel->opcflt;
02227 #           ifndef SKIP_ERT
02228                 ASSERT(iopc < max_opacity);
02229 #           endif
02230             iopc_inv = (float)1. - iopc;
02231             ipixel->clrflt += acc_clr * iopc_inv;
02232             iopc += acc_opc * iopc_inv;
02233             ipixel->opcflt = iopc;
02234             
02235 #ifdef DEBUG
02236     if (ipixel == trace_pixel_ptr) {
02237 #ifdef COMPUTE_SHADOW_BUFFER
02238         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02239 #else
02240         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02241 #endif
02242         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02243         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02244         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02245         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02246         printf("  %3.0f %3.0f\n", iopc*255., 
02247                ipixel->clrflt);
02248         
02249         
02250     }
02251 #endif /* DEBUG */
02252 ;
02253 #           ifndef SKIP_ERT
02254                 if (iopc >= max_opacity) {
02255                     ASSERT(ipixel->lnk == 0);
02256                     ipixel->lnk = 1;
02257                 }
02258 #           endif
02259         };
02260                     ipixel += 1;
02261                     topRLEdata += 1 * voxel_istride;
02262                     botRLEdata += 1 * voxel_istride;
02263                     count--;
02264                     SET_VOXELS_LOADED;
02265                 }
02266                 break;
02267             case ALL_ZERO__BOT_NONZERO:
02268                 /* first pixel: only the bottom-right voxel contributes */
02269                 
02270     
02271             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02272             opacity = param0_table[opac_param];
02273             if (param1_size != 0) {
02274                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02275                 opacity *= param1_table[opac_param];
02276                 if (param2_size != 0) {
02277                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02278                     opacity *= param2_table[opac_param];
02279                 }
02280             }
02281             if (opacity > min_opacity) {
02282                 opacity_int = opacity*255.;
02283                 bot_opc = opac_correct[opacity_int];
02284             } else {
02285                 bot_opc = (float)0.;
02286             };
02287     
02288     
02289     ;
02290     ;
02291     shade_func(botRLEdata, &(bot_clr), client_data);
02292     shade_factor = bot_opc * slice_depth_cueing;
02293     
02294         bot_clr *= shade_factor;
02295     ;
02296                 
02297 #ifdef DEBUG
02298     if (ipixel == trace_pixel_ptr) {
02299         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02300         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02301         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02302         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02303         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02304     }
02305 #endif
02306 ;
02307                 
02308        acc_opc = bot_opc * wgtBR;
02309        acc_clr = bot_clr * wgtBR;
02310        
02311 #ifdef DEBUG
02312     if (ipixel == trace_pixel_ptr) {
02313         trace_opcBR = bot_opc;
02314         trace_rclrBR = bot_clr;
02315         
02316     }
02317 #endif
02318 ;
02319                 
02320         COUNT_RESAMPLE;
02321         if (acc_opc > min_opacity) {
02322             COUNT_COMPOSITE;
02323             iopc = ipixel->opcflt;
02324 #           ifndef SKIP_ERT
02325                 ASSERT(iopc < max_opacity);
02326 #           endif
02327             iopc_inv = (float)1. - iopc;
02328             ipixel->clrflt += acc_clr * iopc_inv;
02329             iopc += acc_opc * iopc_inv;
02330             ipixel->opcflt = iopc;
02331             
02332 #ifdef DEBUG
02333     if (ipixel == trace_pixel_ptr) {
02334 #ifdef COMPUTE_SHADOW_BUFFER
02335         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02336 #else
02337         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02338 #endif
02339         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02340         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02341         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02342         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02343         printf("  %3.0f %3.0f\n", iopc*255., 
02344                ipixel->clrflt);
02345         
02346         
02347     }
02348 #endif /* DEBUG */
02349 ;
02350 #           ifndef SKIP_ERT
02351                 if (iopc >= max_opacity) {
02352                     ASSERT(ipixel->lnk == 0);
02353                     ipixel->lnk = 1;
02354                 }
02355 #           endif
02356         };      
02357                 ipixel += 1;
02358                 topRLEdata += 1 * voxel_istride;
02359                 botRLEdata += 1 * voxel_istride;
02360                 count--;
02361                 SET_VOXELS_LOADED;
02362 
02363                 /* do the rest of the pixels in this run;
02364                    bottom-left and bottom-right voxels contribute */
02365                 while (count > 0) {
02366                     if (PIXEL_IS_OPAQUE(ipixel))
02367                         break;
02368                     if (!voxels_loaded) {
02369                         
02370     
02371             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02372             opacity = param0_table[opac_param];
02373             if (param1_size != 0) {
02374                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02375                 opacity *= param1_table[opac_param];
02376                 if (param2_size != 0) {
02377                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02378                     opacity *= param2_table[opac_param];
02379                 }
02380             }
02381             if (opacity > min_opacity) {
02382                 opacity_int = opacity*255.;
02383                 bot_opc = opac_correct[opacity_int];
02384             } else {
02385                 bot_opc = (float)0.;
02386             };
02387     
02388     
02389     ;
02390     ;
02391     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
02392     shade_factor = bot_opc * slice_depth_cueing;
02393     
02394         bot_clr *= shade_factor;
02395     ;
02396                     }
02397                     
02398 #ifdef DEBUG
02399     if (ipixel == trace_pixel_ptr) {
02400         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02401         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02402         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02403         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02404         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02405     }
02406 #endif
02407 ;
02408                     
02409        acc_opc = bot_opc * wgtBL;
02410        acc_clr = bot_clr * wgtBL;
02411        
02412 #ifdef DEBUG
02413     if (ipixel == trace_pixel_ptr) {
02414         trace_opcBL = bot_opc;
02415         trace_rclrBL = bot_clr;
02416         
02417     }
02418 #endif
02419 ;
02420                     
02421     
02422             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02423             opacity = param0_table[opac_param];
02424             if (param1_size != 0) {
02425                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02426                 opacity *= param1_table[opac_param];
02427                 if (param2_size != 0) {
02428                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02429                     opacity *= param2_table[opac_param];
02430                 }
02431             }
02432             if (opacity > min_opacity) {
02433                 opacity_int = opacity*255.;
02434                 bot_opc = opac_correct[opacity_int];
02435             } else {
02436                 bot_opc = (float)0.;
02437             };
02438     
02439     
02440     ;
02441     ;
02442     shade_func(botRLEdata, &(bot_clr), client_data);
02443     shade_factor = bot_opc * slice_depth_cueing;
02444     
02445         bot_clr *= shade_factor;
02446     ;
02447                     
02448        acc_opc += bot_opc * wgtBR;
02449        acc_clr += bot_clr * wgtBR;
02450        
02451 #ifdef DEBUG
02452     if (ipixel == trace_pixel_ptr) {
02453         trace_opcBR = bot_opc;
02454         trace_rclrBR = bot_clr;
02455         
02456     }
02457 #endif
02458 ;
02459                     
02460         COUNT_RESAMPLE;
02461         if (acc_opc > min_opacity) {
02462             COUNT_COMPOSITE;
02463             iopc = ipixel->opcflt;
02464 #           ifndef SKIP_ERT
02465                 ASSERT(iopc < max_opacity);
02466 #           endif
02467             iopc_inv = (float)1. - iopc;
02468             ipixel->clrflt += acc_clr * iopc_inv;
02469             iopc += acc_opc * iopc_inv;
02470             ipixel->opcflt = iopc;
02471             
02472 #ifdef DEBUG
02473     if (ipixel == trace_pixel_ptr) {
02474 #ifdef COMPUTE_SHADOW_BUFFER
02475         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02476 #else
02477         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02478 #endif
02479         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02480         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02481         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02482         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02483         printf("  %3.0f %3.0f\n", iopc*255., 
02484                ipixel->clrflt);
02485         
02486         
02487     }
02488 #endif /* DEBUG */
02489 ;
02490 #           ifndef SKIP_ERT
02491                 if (iopc >= max_opacity) {
02492                     ASSERT(ipixel->lnk == 0);
02493                     ipixel->lnk = 1;
02494                 }
02495 #           endif
02496         };
02497                     ipixel += 1;
02498                     topRLEdata += 1 * voxel_istride;
02499                     botRLEdata += 1 * voxel_istride;
02500                     count--;
02501                     SET_VOXELS_LOADED;
02502                 }
02503                 break;
02504             case TOP_NONZERO__BOT_NONZERO:
02505                 /* first pixel: top-left and bottom-right voxels contribute */
02506                 if (!voxels_loaded) {
02507                     
02508     
02509             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02510             opacity = param0_table[opac_param];
02511             if (param1_size != 0) {
02512                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02513                 opacity *= param1_table[opac_param];
02514                 if (param2_size != 0) {
02515                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02516                     opacity *= param2_table[opac_param];
02517                 }
02518             }
02519             if (opacity > min_opacity) {
02520                 opacity_int = opacity*255.;
02521                 top_opc = opac_correct[opacity_int];
02522             } else {
02523                 top_opc = (float)0.;
02524             };
02525     
02526     
02527     ;
02528     ;
02529     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
02530     shade_factor = top_opc * slice_depth_cueing;
02531     
02532         top_clr *= shade_factor;
02533     ;
02534                 }
02535                 
02536 #ifdef DEBUG
02537     if (ipixel == trace_pixel_ptr) {
02538         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02539         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02540         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02541         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02542         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02543     }
02544 #endif
02545 ;
02546                 
02547        acc_opc = top_opc * wgtTL;
02548        acc_clr = top_clr * wgtTL;
02549        
02550 #ifdef DEBUG
02551     if (ipixel == trace_pixel_ptr) {
02552         trace_opcTL = top_opc;
02553         trace_rclrTL = top_clr;
02554         
02555     }
02556 #endif
02557 ;
02558                 
02559     
02560             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02561             opacity = param0_table[opac_param];
02562             if (param1_size != 0) {
02563                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02564                 opacity *= param1_table[opac_param];
02565                 if (param2_size != 0) {
02566                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02567                     opacity *= param2_table[opac_param];
02568                 }
02569             }
02570             if (opacity > min_opacity) {
02571                 opacity_int = opacity*255.;
02572                 bot_opc = opac_correct[opacity_int];
02573             } else {
02574                 bot_opc = (float)0.;
02575             };
02576     
02577     
02578     ;
02579     ;
02580     shade_func(botRLEdata, &(bot_clr), client_data);
02581     shade_factor = bot_opc * slice_depth_cueing;
02582     
02583         bot_clr *= shade_factor;
02584     ;
02585                 
02586        acc_opc += bot_opc * wgtBR;
02587        acc_clr += bot_clr * wgtBR;
02588        
02589 #ifdef DEBUG
02590     if (ipixel == trace_pixel_ptr) {
02591         trace_opcBR = bot_opc;
02592         trace_rclrBR = bot_clr;
02593         
02594     }
02595 #endif
02596 ;
02597                 
02598         COUNT_RESAMPLE;
02599         if (acc_opc > min_opacity) {
02600             COUNT_COMPOSITE;
02601             iopc = ipixel->opcflt;
02602 #           ifndef SKIP_ERT
02603                 ASSERT(iopc < max_opacity);
02604 #           endif
02605             iopc_inv = (float)1. - iopc;
02606             ipixel->clrflt += acc_clr * iopc_inv;
02607             iopc += acc_opc * iopc_inv;
02608             ipixel->opcflt = iopc;
02609             
02610 #ifdef DEBUG
02611     if (ipixel == trace_pixel_ptr) {
02612 #ifdef COMPUTE_SHADOW_BUFFER
02613         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02614 #else
02615         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02616 #endif
02617         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02618         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02619         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02620         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02621         printf("  %3.0f %3.0f\n", iopc*255., 
02622                ipixel->clrflt);
02623         
02624         
02625     }
02626 #endif /* DEBUG */
02627 ;
02628 #           ifndef SKIP_ERT
02629                 if (iopc >= max_opacity) {
02630                     ASSERT(ipixel->lnk == 0);
02631                     ipixel->lnk = 1;
02632                 }
02633 #           endif
02634         };
02635                 ipixel += 1;
02636                 topRLEdata += 1 * voxel_istride;
02637                 botRLEdata += 1 * voxel_istride;
02638                 count--;
02639                 SET_VOXELS_LOADED;
02640 
02641                 /* do the rest of the pixels in this run;
02642                    bottom-left and bottom-right voxels contribute */
02643                 while (count > 0) {
02644                     if (PIXEL_IS_OPAQUE(ipixel))
02645                         break;
02646                     if (!voxels_loaded) {
02647                         
02648     
02649             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02650             opacity = param0_table[opac_param];
02651             if (param1_size != 0) {
02652                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02653                 opacity *= param1_table[opac_param];
02654                 if (param2_size != 0) {
02655                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02656                     opacity *= param2_table[opac_param];
02657                 }
02658             }
02659             if (opacity > min_opacity) {
02660                 opacity_int = opacity*255.;
02661                 bot_opc = opac_correct[opacity_int];
02662             } else {
02663                 bot_opc = (float)0.;
02664             };
02665     
02666     
02667     ;
02668     ;
02669     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
02670     shade_factor = bot_opc * slice_depth_cueing;
02671     
02672         bot_clr *= shade_factor;
02673     ;
02674                     }
02675                     
02676 #ifdef DEBUG
02677     if (ipixel == trace_pixel_ptr) {
02678         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02679         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02680         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02681         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02682         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02683     }
02684 #endif
02685 ;
02686                     
02687        acc_opc = bot_opc * wgtBL;
02688        acc_clr = bot_clr * wgtBL;
02689        
02690 #ifdef DEBUG
02691     if (ipixel == trace_pixel_ptr) {
02692         trace_opcBL = bot_opc;
02693         trace_rclrBL = bot_clr;
02694         
02695     }
02696 #endif
02697 ;
02698                     
02699     
02700             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02701             opacity = param0_table[opac_param];
02702             if (param1_size != 0) {
02703                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02704                 opacity *= param1_table[opac_param];
02705                 if (param2_size != 0) {
02706                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02707                     opacity *= param2_table[opac_param];
02708                 }
02709             }
02710             if (opacity > min_opacity) {
02711                 opacity_int = opacity*255.;
02712                 bot_opc = opac_correct[opacity_int];
02713             } else {
02714                 bot_opc = (float)0.;
02715             };
02716     
02717     
02718     ;
02719     ;
02720     shade_func(botRLEdata, &(bot_clr), client_data);
02721     shade_factor = bot_opc * slice_depth_cueing;
02722     
02723         bot_clr *= shade_factor;
02724     ;
02725                     
02726        acc_opc += bot_opc * wgtBR;
02727        acc_clr += bot_clr * wgtBR;
02728        
02729 #ifdef DEBUG
02730     if (ipixel == trace_pixel_ptr) {
02731         trace_opcBR = bot_opc;
02732         trace_rclrBR = bot_clr;
02733         
02734     }
02735 #endif
02736 ;
02737                     
02738         COUNT_RESAMPLE;
02739         if (acc_opc > min_opacity) {
02740             COUNT_COMPOSITE;
02741             iopc = ipixel->opcflt;
02742 #           ifndef SKIP_ERT
02743                 ASSERT(iopc < max_opacity);
02744 #           endif
02745             iopc_inv = (float)1. - iopc;
02746             ipixel->clrflt += acc_clr * iopc_inv;
02747             iopc += acc_opc * iopc_inv;
02748             ipixel->opcflt = iopc;
02749             
02750 #ifdef DEBUG
02751     if (ipixel == trace_pixel_ptr) {
02752 #ifdef COMPUTE_SHADOW_BUFFER
02753         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02754 #else
02755         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02756 #endif
02757         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02758         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02759         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02760         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02761         printf("  %3.0f %3.0f\n", iopc*255., 
02762                ipixel->clrflt);
02763         
02764         
02765     }
02766 #endif /* DEBUG */
02767 ;
02768 #           ifndef SKIP_ERT
02769                 if (iopc >= max_opacity) {
02770                     ASSERT(ipixel->lnk == 0);
02771                     ipixel->lnk = 1;
02772                 }
02773 #           endif
02774         };
02775                     ipixel += 1;
02776                     topRLEdata += 1 * voxel_istride;
02777                     botRLEdata += 1 * voxel_istride;
02778                     count--;
02779                     SET_VOXELS_LOADED;
02780                 }
02781                 break;
02782             case BOT_NONZERO__BOT_NONZERO:
02783                 /* do the pixels in this run; bottom-left and
02784                    bottom-right voxels contribute */
02785                 while (count > 0) {
02786                     if (PIXEL_IS_OPAQUE(ipixel))
02787                         break;
02788                     if (!voxels_loaded) {
02789                         
02790     
02791             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02792             opacity = param0_table[opac_param];
02793             if (param1_size != 0) {
02794                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02795                 opacity *= param1_table[opac_param];
02796                 if (param2_size != 0) {
02797                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02798                     opacity *= param2_table[opac_param];
02799                 }
02800             }
02801             if (opacity > min_opacity) {
02802                 opacity_int = opacity*255.;
02803                 bot_opc = opac_correct[opacity_int];
02804             } else {
02805                 bot_opc = (float)0.;
02806             };
02807     
02808     
02809     ;
02810     ;
02811     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
02812     shade_factor = bot_opc * slice_depth_cueing;
02813     
02814         bot_clr *= shade_factor;
02815     ;
02816                     }
02817                     
02818 #ifdef DEBUG
02819     if (ipixel == trace_pixel_ptr) {
02820         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02821         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02822         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02823         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02824         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02825     }
02826 #endif
02827 ;
02828                     
02829        acc_opc = bot_opc * wgtBL;
02830        acc_clr = bot_clr * wgtBL;
02831        
02832 #ifdef DEBUG
02833     if (ipixel == trace_pixel_ptr) {
02834         trace_opcBL = bot_opc;
02835         trace_rclrBL = bot_clr;
02836         
02837     }
02838 #endif
02839 ;
02840                     
02841     
02842             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02843             opacity = param0_table[opac_param];
02844             if (param1_size != 0) {
02845                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02846                 opacity *= param1_table[opac_param];
02847                 if (param2_size != 0) {
02848                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02849                     opacity *= param2_table[opac_param];
02850                 }
02851             }
02852             if (opacity > min_opacity) {
02853                 opacity_int = opacity*255.;
02854                 bot_opc = opac_correct[opacity_int];
02855             } else {
02856                 bot_opc = (float)0.;
02857             };
02858     
02859     
02860     ;
02861     ;
02862     shade_func(botRLEdata, &(bot_clr), client_data);
02863     shade_factor = bot_opc * slice_depth_cueing;
02864     
02865         bot_clr *= shade_factor;
02866     ;
02867                     
02868        acc_opc += bot_opc * wgtBR;
02869        acc_clr += bot_clr * wgtBR;
02870        
02871 #ifdef DEBUG
02872     if (ipixel == trace_pixel_ptr) {
02873         trace_opcBR = bot_opc;
02874         trace_rclrBR = bot_clr;
02875         
02876     }
02877 #endif
02878 ;
02879                     
02880         COUNT_RESAMPLE;
02881         if (acc_opc > min_opacity) {
02882             COUNT_COMPOSITE;
02883             iopc = ipixel->opcflt;
02884 #           ifndef SKIP_ERT
02885                 ASSERT(iopc < max_opacity);
02886 #           endif
02887             iopc_inv = (float)1. - iopc;
02888             ipixel->clrflt += acc_clr * iopc_inv;
02889             iopc += acc_opc * iopc_inv;
02890             ipixel->opcflt = iopc;
02891             
02892 #ifdef DEBUG
02893     if (ipixel == trace_pixel_ptr) {
02894 #ifdef COMPUTE_SHADOW_BUFFER
02895         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02896 #else
02897         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02898 #endif
02899         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02900         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02901         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02902         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02903         printf("  %3.0f %3.0f\n", iopc*255., 
02904                ipixel->clrflt);
02905         
02906         
02907     }
02908 #endif /* DEBUG */
02909 ;
02910 #           ifndef SKIP_ERT
02911                 if (iopc >= max_opacity) {
02912                     ASSERT(ipixel->lnk == 0);
02913                     ipixel->lnk = 1;
02914                 }
02915 #           endif
02916         };
02917                     ipixel += 1;
02918                     topRLEdata += 1 * voxel_istride;
02919                     botRLEdata += 1 * voxel_istride;
02920                     count--;
02921                     SET_VOXELS_LOADED;
02922                 }
02923                 break;
02924             case ALL_NONZERO__BOT_NONZERO:
02925                 /* first pixel: top-left, bottom-left and bottom-right
02926                    voxels contribute */
02927                 if (!voxels_loaded) {
02928                     
02929     
02930             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02931             opacity = param0_table[opac_param];
02932             if (param1_size != 0) {
02933                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02934                 opacity *= param1_table[opac_param];
02935                 if (param2_size != 0) {
02936                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02937                     opacity *= param2_table[opac_param];
02938                 }
02939             }
02940             if (opacity > min_opacity) {
02941                 opacity_int = opacity*255.;
02942                 top_opc = opac_correct[opacity_int];
02943             } else {
02944                 top_opc = (float)0.;
02945             };
02946     
02947     
02948     ;
02949     ;
02950     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
02951     shade_factor = top_opc * slice_depth_cueing;
02952     
02953         top_clr *= shade_factor;
02954     ;
02955                     
02956     
02957             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02958             opacity = param0_table[opac_param];
02959             if (param1_size != 0) {
02960                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02961                 opacity *= param1_table[opac_param];
02962                 if (param2_size != 0) {
02963                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02964                     opacity *= param2_table[opac_param];
02965                 }
02966             }
02967             if (opacity > min_opacity) {
02968                 opacity_int = opacity*255.;
02969                 bot_opc = opac_correct[opacity_int];
02970             } else {
02971                 bot_opc = (float)0.;
02972             };
02973     
02974     
02975     ;
02976     ;
02977     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
02978     shade_factor = bot_opc * slice_depth_cueing;
02979     
02980         bot_clr *= shade_factor;
02981     ;
02982                 }
02983                 
02984 #ifdef DEBUG
02985     if (ipixel == trace_pixel_ptr) {
02986         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02987         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02988         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02989         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02990         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02991     }
02992 #endif
02993 ;
02994                 
02995        acc_opc = top_opc * wgtTL;
02996        acc_clr = top_clr * wgtTL;
02997        
02998 #ifdef DEBUG
02999     if (ipixel == trace_pixel_ptr) {
03000         trace_opcTL = top_opc;
03001         trace_rclrTL = top_clr;
03002         
03003     }
03004 #endif
03005 ;
03006                 
03007        acc_opc += bot_opc * wgtBL;
03008        acc_clr += bot_clr * wgtBL;
03009        
03010 #ifdef DEBUG
03011     if (ipixel == trace_pixel_ptr) {
03012         trace_opcBL = bot_opc;
03013         trace_rclrBL = bot_clr;
03014         
03015     }
03016 #endif
03017 ;
03018                 
03019     
03020             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03021             opacity = param0_table[opac_param];
03022             if (param1_size != 0) {
03023                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03024                 opacity *= param1_table[opac_param];
03025                 if (param2_size != 0) {
03026                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03027                     opacity *= param2_table[opac_param];
03028                 }
03029             }
03030             if (opacity > min_opacity) {
03031                 opacity_int = opacity*255.;
03032                 bot_opc = opac_correct[opacity_int];
03033             } else {
03034                 bot_opc = (float)0.;
03035             };
03036     
03037     
03038     ;
03039     ;
03040     shade_func(botRLEdata, &(bot_clr), client_data);
03041     shade_factor = bot_opc * slice_depth_cueing;
03042     
03043         bot_clr *= shade_factor;
03044     ;
03045                 
03046        acc_opc += bot_opc * wgtBR;
03047        acc_clr += bot_clr * wgtBR;
03048        
03049 #ifdef DEBUG
03050     if (ipixel == trace_pixel_ptr) {
03051         trace_opcBR = bot_opc;
03052         trace_rclrBR = bot_clr;
03053         
03054     }
03055 #endif
03056 ;
03057                 
03058         COUNT_RESAMPLE;
03059         if (acc_opc > min_opacity) {
03060             COUNT_COMPOSITE;
03061             iopc = ipixel->opcflt;
03062 #           ifndef SKIP_ERT
03063                 ASSERT(iopc < max_opacity);
03064 #           endif
03065             iopc_inv = (float)1. - iopc;
03066             ipixel->clrflt += acc_clr * iopc_inv;
03067             iopc += acc_opc * iopc_inv;
03068             ipixel->opcflt = iopc;
03069             
03070 #ifdef DEBUG
03071     if (ipixel == trace_pixel_ptr) {
03072 #ifdef COMPUTE_SHADOW_BUFFER
03073         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03074 #else
03075         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03076 #endif
03077         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03078         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03079         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03080         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03081         printf("  %3.0f %3.0f\n", iopc*255., 
03082                ipixel->clrflt);
03083         
03084         
03085     }
03086 #endif /* DEBUG */
03087 ;
03088 #           ifndef SKIP_ERT
03089                 if (iopc >= max_opacity) {
03090                     ASSERT(ipixel->lnk == 0);
03091                     ipixel->lnk = 1;
03092                 }
03093 #           endif
03094         };
03095                 ipixel += 1;
03096                 topRLEdata += 1 * voxel_istride;
03097                 botRLEdata += 1 * voxel_istride;
03098                 count--;
03099                 SET_VOXELS_LOADED;
03100 
03101                 /* do the rest of the pixels in this run;
03102                    bottom-left and bottom-right voxels contribute */
03103                 while (count > 0) {
03104                     if (PIXEL_IS_OPAQUE(ipixel))
03105                         break;
03106                     if (!voxels_loaded) {
03107                         
03108     
03109             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03110             opacity = param0_table[opac_param];
03111             if (param1_size != 0) {
03112                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03113                 opacity *= param1_table[opac_param];
03114                 if (param2_size != 0) {
03115                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03116                     opacity *= param2_table[opac_param];
03117                 }
03118             }
03119             if (opacity > min_opacity) {
03120                 opacity_int = opacity*255.;
03121                 bot_opc = opac_correct[opacity_int];
03122             } else {
03123                 bot_opc = (float)0.;
03124             };
03125     
03126     
03127     ;
03128     ;
03129     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
03130     shade_factor = bot_opc * slice_depth_cueing;
03131     
03132         bot_clr *= shade_factor;
03133     ;
03134                     }
03135                     
03136 #ifdef DEBUG
03137     if (ipixel == trace_pixel_ptr) {
03138         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03139         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03140         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03141         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03142         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03143     }
03144 #endif
03145 ;
03146                     
03147        acc_opc = bot_opc * wgtBL;
03148        acc_clr = bot_clr * wgtBL;
03149        
03150 #ifdef DEBUG
03151     if (ipixel == trace_pixel_ptr) {
03152         trace_opcBL = bot_opc;
03153         trace_rclrBL = bot_clr;
03154         
03155     }
03156 #endif
03157 ;
03158                     
03159     
03160             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03161             opacity = param0_table[opac_param];
03162             if (param1_size != 0) {
03163                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03164                 opacity *= param1_table[opac_param];
03165                 if (param2_size != 0) {
03166                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03167                     opacity *= param2_table[opac_param];
03168                 }
03169             }
03170             if (opacity > min_opacity) {
03171                 opacity_int = opacity*255.;
03172                 bot_opc = opac_correct[opacity_int];
03173             } else {
03174                 bot_opc = (float)0.;
03175             };
03176     
03177     
03178     ;
03179     ;
03180     shade_func(botRLEdata, &(bot_clr), client_data);
03181     shade_factor = bot_opc * slice_depth_cueing;
03182     
03183         bot_clr *= shade_factor;
03184     ;
03185                     
03186        acc_opc += bot_opc * wgtBR;
03187        acc_clr += bot_clr * wgtBR;
03188        
03189 #ifdef DEBUG
03190     if (ipixel == trace_pixel_ptr) {
03191         trace_opcBR = bot_opc;
03192         trace_rclrBR = bot_clr;
03193         
03194     }
03195 #endif
03196 ;
03197                     
03198         COUNT_RESAMPLE;
03199         if (acc_opc > min_opacity) {
03200             COUNT_COMPOSITE;
03201             iopc = ipixel->opcflt;
03202 #           ifndef SKIP_ERT
03203                 ASSERT(iopc < max_opacity);
03204 #           endif
03205             iopc_inv = (float)1. - iopc;
03206             ipixel->clrflt += acc_clr * iopc_inv;
03207             iopc += acc_opc * iopc_inv;
03208             ipixel->opcflt = iopc;
03209             
03210 #ifdef DEBUG
03211     if (ipixel == trace_pixel_ptr) {
03212 #ifdef COMPUTE_SHADOW_BUFFER
03213         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03214 #else
03215         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03216 #endif
03217         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03218         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03219         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03220         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03221         printf("  %3.0f %3.0f\n", iopc*255., 
03222                ipixel->clrflt);
03223         
03224         
03225     }
03226 #endif /* DEBUG */
03227 ;
03228 #           ifndef SKIP_ERT
03229                 if (iopc >= max_opacity) {
03230                     ASSERT(ipixel->lnk == 0);
03231                     ipixel->lnk = 1;
03232                 }
03233 #           endif
03234         };
03235                     ipixel += 1;
03236                     topRLEdata += 1 * voxel_istride;
03237                     botRLEdata += 1 * voxel_istride;
03238                     count--;
03239                     SET_VOXELS_LOADED;
03240                 }
03241                 break;
03242             case ALL_ZERO__ALL_NONZERO:
03243                 /* first pixel: top-right and bottom-right voxels contribute */
03244                 
03245     
03246             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03247             opacity = param0_table[opac_param];
03248             if (param1_size != 0) {
03249                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03250                 opacity *= param1_table[opac_param];
03251                 if (param2_size != 0) {
03252                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03253                     opacity *= param2_table[opac_param];
03254                 }
03255             }
03256             if (opacity > min_opacity) {
03257                 opacity_int = opacity*255.;
03258                 top_opc = opac_correct[opacity_int];
03259             } else {
03260                 top_opc = (float)0.;
03261             };
03262     
03263     
03264     ;
03265     ;
03266     shade_func(topRLEdata, &(top_clr), client_data);
03267     shade_factor = top_opc * slice_depth_cueing;
03268     
03269         top_clr *= shade_factor;
03270     ;
03271                 
03272     
03273             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03274             opacity = param0_table[opac_param];
03275             if (param1_size != 0) {
03276                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03277                 opacity *= param1_table[opac_param];
03278                 if (param2_size != 0) {
03279                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03280                     opacity *= param2_table[opac_param];
03281                 }
03282             }
03283             if (opacity > min_opacity) {
03284                 opacity_int = opacity*255.;
03285                 bot_opc = opac_correct[opacity_int];
03286             } else {
03287                 bot_opc = (float)0.;
03288             };
03289     
03290     
03291     ;
03292     ;
03293     shade_func(botRLEdata, &(bot_clr), client_data);
03294     shade_factor = bot_opc * slice_depth_cueing;
03295     
03296         bot_clr *= shade_factor;
03297     ;
03298                 
03299 #ifdef DEBUG
03300     if (ipixel == trace_pixel_ptr) {
03301         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03302         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03303         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03304         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03305         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03306     }
03307 #endif
03308 ;
03309                 
03310        acc_opc = top_opc * wgtTR;
03311        acc_clr = top_clr * wgtTR;
03312        
03313 #ifdef DEBUG
03314     if (ipixel == trace_pixel_ptr) {
03315         trace_opcTR = top_opc;
03316         trace_rclrTR = top_clr;
03317         
03318     }
03319 #endif
03320 ;
03321                 
03322        acc_opc += bot_opc * wgtBR;
03323        acc_clr += bot_clr * wgtBR;
03324        
03325 #ifdef DEBUG
03326     if (ipixel == trace_pixel_ptr) {
03327         trace_opcBR = bot_opc;
03328         trace_rclrBR = bot_clr;
03329         
03330     }
03331 #endif
03332 ;
03333                 
03334         COUNT_RESAMPLE;
03335         if (acc_opc > min_opacity) {
03336             COUNT_COMPOSITE;
03337             iopc = ipixel->opcflt;
03338 #           ifndef SKIP_ERT
03339                 ASSERT(iopc < max_opacity);
03340 #           endif
03341             iopc_inv = (float)1. - iopc;
03342             ipixel->clrflt += acc_clr * iopc_inv;
03343             iopc += acc_opc * iopc_inv;
03344             ipixel->opcflt = iopc;
03345             
03346 #ifdef DEBUG
03347     if (ipixel == trace_pixel_ptr) {
03348 #ifdef COMPUTE_SHADOW_BUFFER
03349         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03350 #else
03351         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03352 #endif
03353         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03354         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03355         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03356         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03357         printf("  %3.0f %3.0f\n", iopc*255., 
03358                ipixel->clrflt);
03359         
03360         
03361     }
03362 #endif /* DEBUG */
03363 ;
03364 #           ifndef SKIP_ERT
03365                 if (iopc >= max_opacity) {
03366                     ASSERT(ipixel->lnk == 0);
03367                     ipixel->lnk = 1;
03368                 }
03369 #           endif
03370         };
03371                 ipixel += 1;
03372                 topRLEdata += 1 * voxel_istride;
03373                 botRLEdata += 1 * voxel_istride;
03374                 count--;
03375                 SET_VOXELS_LOADED;
03376 
03377                 /* do the rest of the pixels in this run;
03378                    all four voxels contribute */
03379                 while (count > 0) {
03380                     if (PIXEL_IS_OPAQUE(ipixel))
03381                         break;
03382                     if (!voxels_loaded) {
03383                         
03384     
03385             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03386             opacity = param0_table[opac_param];
03387             if (param1_size != 0) {
03388                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03389                 opacity *= param1_table[opac_param];
03390                 if (param2_size != 0) {
03391                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03392                     opacity *= param2_table[opac_param];
03393                 }
03394             }
03395             if (opacity > min_opacity) {
03396                 opacity_int = opacity*255.;
03397                 top_opc = opac_correct[opacity_int];
03398             } else {
03399                 top_opc = (float)0.;
03400             };
03401     
03402     
03403     ;
03404     ;
03405     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
03406     shade_factor = top_opc * slice_depth_cueing;
03407     
03408         top_clr *= shade_factor;
03409     ;
03410                         
03411     
03412             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03413             opacity = param0_table[opac_param];
03414             if (param1_size != 0) {
03415                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03416                 opacity *= param1_table[opac_param];
03417                 if (param2_size != 0) {
03418                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03419                     opacity *= param2_table[opac_param];
03420                 }
03421             }
03422             if (opacity > min_opacity) {
03423                 opacity_int = opacity*255.;
03424                 bot_opc = opac_correct[opacity_int];
03425             } else {
03426                 bot_opc = (float)0.;
03427             };
03428     
03429     
03430     ;
03431     ;
03432     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
03433     shade_factor = bot_opc * slice_depth_cueing;
03434     
03435         bot_clr *= shade_factor;
03436     ;
03437                     }
03438                     
03439 #ifdef DEBUG
03440     if (ipixel == trace_pixel_ptr) {
03441         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03442         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03443         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03444         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03445         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03446     }
03447 #endif
03448 ;
03449                     
03450        acc_opc = top_opc * wgtTL;
03451        acc_clr = top_clr * wgtTL;
03452        
03453 #ifdef DEBUG
03454     if (ipixel == trace_pixel_ptr) {
03455         trace_opcTL = top_opc;
03456         trace_rclrTL = top_clr;
03457         
03458     }
03459 #endif
03460 ;
03461                     
03462        acc_opc += bot_opc * wgtBL;
03463        acc_clr += bot_clr * wgtBL;
03464        
03465 #ifdef DEBUG
03466     if (ipixel == trace_pixel_ptr) {
03467         trace_opcBL = bot_opc;
03468         trace_rclrBL = bot_clr;
03469         
03470     }
03471 #endif
03472 ;
03473                     
03474     
03475             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03476             opacity = param0_table[opac_param];
03477             if (param1_size != 0) {
03478                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03479                 opacity *= param1_table[opac_param];
03480                 if (param2_size != 0) {
03481                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03482                     opacity *= param2_table[opac_param];
03483                 }
03484             }
03485             if (opacity > min_opacity) {
03486                 opacity_int = opacity*255.;
03487                 top_opc = opac_correct[opacity_int];
03488             } else {
03489                 top_opc = (float)0.;
03490             };
03491     
03492     
03493     ;
03494     ;
03495     shade_func(topRLEdata, &(top_clr), client_data);
03496     shade_factor = top_opc * slice_depth_cueing;
03497     
03498         top_clr *= shade_factor;
03499     ;
03500                     
03501     
03502             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03503             opacity = param0_table[opac_param];
03504             if (param1_size != 0) {
03505                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03506                 opacity *= param1_table[opac_param];
03507                 if (param2_size != 0) {
03508                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03509                     opacity *= param2_table[opac_param];
03510                 }
03511             }
03512             if (opacity > min_opacity) {
03513                 opacity_int = opacity*255.;
03514                 bot_opc = opac_correct[opacity_int];
03515             } else {
03516                 bot_opc = (float)0.;
03517             };
03518     
03519     
03520     ;
03521     ;
03522     shade_func(botRLEdata, &(bot_clr), client_data);
03523     shade_factor = bot_opc * slice_depth_cueing;
03524     
03525         bot_clr *= shade_factor;
03526     ;
03527                     
03528        acc_opc += top_opc * wgtTR;
03529        acc_clr += top_clr * wgtTR;
03530        
03531 #ifdef DEBUG
03532     if (ipixel == trace_pixel_ptr) {
03533         trace_opcTR = top_opc;
03534         trace_rclrTR = top_clr;
03535         
03536     }
03537 #endif
03538 ;
03539                     
03540        acc_opc += bot_opc * wgtBR;
03541        acc_clr += bot_clr * wgtBR;
03542        
03543 #ifdef DEBUG
03544     if (ipixel == trace_pixel_ptr) {
03545         trace_opcBR = bot_opc;
03546         trace_rclrBR = bot_clr;
03547         
03548     }
03549 #endif
03550 ;
03551                     
03552         COUNT_RESAMPLE;
03553         if (acc_opc > min_opacity) {
03554             COUNT_COMPOSITE;
03555             iopc = ipixel->opcflt;
03556 #           ifndef SKIP_ERT
03557                 ASSERT(iopc < max_opacity);
03558 #           endif
03559             iopc_inv = (float)1. - iopc;
03560             ipixel->clrflt += acc_clr * iopc_inv;
03561             iopc += acc_opc * iopc_inv;
03562             ipixel->opcflt = iopc;
03563             
03564 #ifdef DEBUG
03565     if (ipixel == trace_pixel_ptr) {
03566 #ifdef COMPUTE_SHADOW_BUFFER
03567         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03568 #else
03569         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03570 #endif
03571         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03572         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03573         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03574         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03575         printf("  %3.0f %3.0f\n", iopc*255., 
03576                ipixel->clrflt);
03577         
03578         
03579     }
03580 #endif /* DEBUG */
03581 ;
03582 #           ifndef SKIP_ERT
03583                 if (iopc >= max_opacity) {
03584                     ASSERT(ipixel->lnk == 0);
03585                     ipixel->lnk = 1;
03586                 }
03587 #           endif
03588         };
03589                     ipixel += 1;
03590                     topRLEdata += 1 * voxel_istride;
03591                     botRLEdata += 1 * voxel_istride;
03592                     count--;
03593                     SET_VOXELS_LOADED;
03594                 }
03595                 break;
03596             case TOP_NONZERO__ALL_NONZERO:
03597                 /* first pixel: top-left, top-right and bottom-right
03598                    voxels contribute */
03599                 if (!voxels_loaded) {
03600                     
03601     
03602             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03603             opacity = param0_table[opac_param];
03604             if (param1_size != 0) {
03605                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03606                 opacity *= param1_table[opac_param];
03607                 if (param2_size != 0) {
03608                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03609                     opacity *= param2_table[opac_param];
03610                 }
03611             }
03612             if (opacity > min_opacity) {
03613                 opacity_int = opacity*255.;
03614                 top_opc = opac_correct[opacity_int];
03615             } else {
03616                 top_opc = (float)0.;
03617             };
03618     
03619     
03620     ;
03621     ;
03622     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
03623     shade_factor = top_opc * slice_depth_cueing;
03624     
03625         top_clr *= shade_factor;
03626     ;
03627                 }
03628                 
03629 #ifdef DEBUG
03630     if (ipixel == trace_pixel_ptr) {
03631         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03632         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03633         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03634         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03635         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03636     }
03637 #endif
03638 ;
03639                 
03640        acc_opc = top_opc * wgtTL;
03641        acc_clr = top_clr * wgtTL;
03642        
03643 #ifdef DEBUG
03644     if (ipixel == trace_pixel_ptr) {
03645         trace_opcTL = top_opc;
03646         trace_rclrTL = top_clr;
03647         
03648     }
03649 #endif
03650 ;
03651                 
03652     
03653             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03654             opacity = param0_table[opac_param];
03655             if (param1_size != 0) {
03656                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03657                 opacity *= param1_table[opac_param];
03658                 if (param2_size != 0) {
03659                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03660                     opacity *= param2_table[opac_param];
03661                 }
03662             }
03663             if (opacity > min_opacity) {
03664                 opacity_int = opacity*255.;
03665                 top_opc = opac_correct[opacity_int];
03666             } else {
03667                 top_opc = (float)0.;
03668             };
03669     
03670     
03671     ;
03672     ;
03673     shade_func(topRLEdata, &(top_clr), client_data);
03674     shade_factor = top_opc * slice_depth_cueing;
03675     
03676         top_clr *= shade_factor;
03677     ;
03678                 
03679     
03680             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03681             opacity = param0_table[opac_param];
03682             if (param1_size != 0) {
03683                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03684                 opacity *= param1_table[opac_param];
03685                 if (param2_size != 0) {
03686                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03687                     opacity *= param2_table[opac_param];
03688                 }
03689             }
03690             if (opacity > min_opacity) {
03691                 opacity_int = opacity*255.;
03692                 bot_opc = opac_correct[opacity_int];
03693             } else {
03694                 bot_opc = (float)0.;
03695             };
03696     
03697     
03698     ;
03699     ;
03700     shade_func(botRLEdata, &(bot_clr), client_data);
03701     shade_factor = bot_opc * slice_depth_cueing;
03702     
03703         bot_clr *= shade_factor;
03704     ;
03705                 
03706        acc_opc += top_opc * wgtTR;
03707        acc_clr += top_clr * wgtTR;
03708        
03709 #ifdef DEBUG
03710     if (ipixel == trace_pixel_ptr) {
03711         trace_opcTR = top_opc;
03712         trace_rclrTR = top_clr;
03713         
03714     }
03715 #endif
03716 ;
03717                 
03718        acc_opc += bot_opc * wgtBR;
03719        acc_clr += bot_clr * wgtBR;
03720        
03721 #ifdef DEBUG
03722     if (ipixel == trace_pixel_ptr) {
03723         trace_opcBR = bot_opc;
03724         trace_rclrBR = bot_clr;
03725         
03726     }
03727 #endif
03728 ;
03729                 
03730         COUNT_RESAMPLE;
03731         if (acc_opc > min_opacity) {
03732             COUNT_COMPOSITE;
03733             iopc = ipixel->opcflt;
03734 #           ifndef SKIP_ERT
03735                 ASSERT(iopc < max_opacity);
03736 #           endif
03737             iopc_inv = (float)1. - iopc;
03738             ipixel->clrflt += acc_clr * iopc_inv;
03739             iopc += acc_opc * iopc_inv;
03740             ipixel->opcflt = iopc;
03741             
03742 #ifdef DEBUG
03743     if (ipixel == trace_pixel_ptr) {
03744 #ifdef COMPUTE_SHADOW_BUFFER
03745         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03746 #else
03747         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03748 #endif
03749         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03750         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03751         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03752         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03753         printf("  %3.0f %3.0f\n", iopc*255., 
03754                ipixel->clrflt);
03755         
03756         
03757     }
03758 #endif /* DEBUG */
03759 ;
03760 #           ifndef SKIP_ERT
03761                 if (iopc >= max_opacity) {
03762                     ASSERT(ipixel->lnk == 0);
03763                     ipixel->lnk = 1;
03764                 }
03765 #           endif
03766         };
03767                 ipixel += 1;
03768                 topRLEdata += 1 * voxel_istride;
03769                 botRLEdata += 1 * voxel_istride;
03770                 count--;
03771                 SET_VOXELS_LOADED;
03772                     
03773                 /* do the rest of the pixels in this run;
03774                    all four voxels contribute */
03775                 while (count > 0) {
03776                     if (PIXEL_IS_OPAQUE(ipixel))
03777                         break;
03778                     if (!voxels_loaded) {
03779                         
03780     
03781             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03782             opacity = param0_table[opac_param];
03783             if (param1_size != 0) {
03784                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03785                 opacity *= param1_table[opac_param];
03786                 if (param2_size != 0) {
03787                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03788                     opacity *= param2_table[opac_param];
03789                 }
03790             }
03791             if (opacity > min_opacity) {
03792                 opacity_int = opacity*255.;
03793                 top_opc = opac_correct[opacity_int];
03794             } else {
03795                 top_opc = (float)0.;
03796             };
03797     
03798     
03799     ;
03800     ;
03801     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
03802     shade_factor = top_opc * slice_depth_cueing;
03803     
03804         top_clr *= shade_factor;
03805     ;
03806                         
03807     
03808             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03809             opacity = param0_table[opac_param];
03810             if (param1_size != 0) {
03811                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03812                 opacity *= param1_table[opac_param];
03813                 if (param2_size != 0) {
03814                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03815                     opacity *= param2_table[opac_param];
03816                 }
03817             }
03818             if (opacity > min_opacity) {
03819                 opacity_int = opacity*255.;
03820                 bot_opc = opac_correct[opacity_int];
03821             } else {
03822                 bot_opc = (float)0.;
03823             };
03824     
03825     
03826     ;
03827     ;
03828     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
03829     shade_factor = bot_opc * slice_depth_cueing;
03830     
03831         bot_clr *= shade_factor;
03832     ;
03833                     }
03834                     
03835 #ifdef DEBUG
03836     if (ipixel == trace_pixel_ptr) {
03837         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03838         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03839         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03840         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03841         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03842     }
03843 #endif
03844 ;
03845                     
03846        acc_opc = top_opc * wgtTL;
03847        acc_clr = top_clr * wgtTL;
03848        
03849 #ifdef DEBUG
03850     if (ipixel == trace_pixel_ptr) {
03851         trace_opcTL = top_opc;
03852         trace_rclrTL = top_clr;
03853         
03854     }
03855 #endif
03856 ;
03857                     
03858        acc_opc += bot_opc * wgtBL;
03859        acc_clr += bot_clr * wgtBL;
03860        
03861 #ifdef DEBUG
03862     if (ipixel == trace_pixel_ptr) {
03863         trace_opcBL = bot_opc;
03864         trace_rclrBL = bot_clr;
03865         
03866     }
03867 #endif
03868 ;
03869                     
03870     
03871             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03872             opacity = param0_table[opac_param];
03873             if (param1_size != 0) {
03874                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03875                 opacity *= param1_table[opac_param];
03876                 if (param2_size != 0) {
03877                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03878                     opacity *= param2_table[opac_param];
03879                 }
03880             }
03881             if (opacity > min_opacity) {
03882                 opacity_int = opacity*255.;
03883                 top_opc = opac_correct[opacity_int];
03884             } else {
03885                 top_opc = (float)0.;
03886             };
03887     
03888     
03889     ;
03890     ;
03891     shade_func(topRLEdata, &(top_clr), client_data);
03892     shade_factor = top_opc * slice_depth_cueing;
03893     
03894         top_clr *= shade_factor;
03895     ;
03896                     
03897     
03898             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03899             opacity = param0_table[opac_param];
03900             if (param1_size != 0) {
03901                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03902                 opacity *= param1_table[opac_param];
03903                 if (param2_size != 0) {
03904                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03905                     opacity *= param2_table[opac_param];
03906                 }
03907             }
03908             if (opacity > min_opacity) {
03909                 opacity_int = opacity*255.;
03910                 bot_opc = opac_correct[opacity_int];
03911             } else {
03912                 bot_opc = (float)0.;
03913             };
03914     
03915     
03916     ;
03917     ;
03918     shade_func(botRLEdata, &(bot_clr), client_data);
03919     shade_factor = bot_opc * slice_depth_cueing;
03920     
03921         bot_clr *= shade_factor;
03922     ;
03923                     
03924        acc_opc += top_opc * wgtTR;
03925        acc_clr += top_clr * wgtTR;
03926        
03927 #ifdef DEBUG
03928     if (ipixel == trace_pixel_ptr) {
03929         trace_opcTR = top_opc;
03930         trace_rclrTR = top_clr;
03931         
03932     }
03933 #endif
03934 ;
03935                     
03936        acc_opc += bot_opc * wgtBR;
03937        acc_clr += bot_clr * wgtBR;
03938        
03939 #ifdef DEBUG
03940     if (ipixel == trace_pixel_ptr) {
03941         trace_opcBR = bot_opc;
03942         trace_rclrBR = bot_clr;
03943         
03944     }
03945 #endif
03946 ;
03947                     
03948         COUNT_RESAMPLE;
03949         if (acc_opc > min_opacity) {
03950             COUNT_COMPOSITE;
03951             iopc = ipixel->opcflt;
03952 #           ifndef SKIP_ERT
03953                 ASSERT(iopc < max_opacity);
03954 #           endif
03955             iopc_inv = (float)1. - iopc;
03956             ipixel->clrflt += acc_clr * iopc_inv;
03957             iopc += acc_opc * iopc_inv;
03958             ipixel->opcflt = iopc;
03959             
03960 #ifdef DEBUG
03961     if (ipixel == trace_pixel_ptr) {
03962 #ifdef COMPUTE_SHADOW_BUFFER
03963         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03964 #else
03965         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03966 #endif
03967         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03968         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03969         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03970         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03971         printf("  %3.0f %3.0f\n", iopc*255., 
03972                ipixel->clrflt);
03973         
03974         
03975     }
03976 #endif /* DEBUG */
03977 ;
03978 #           ifndef SKIP_ERT
03979                 if (iopc >= max_opacity) {
03980                     ASSERT(ipixel->lnk == 0);
03981                     ipixel->lnk = 1;
03982                 }
03983 #           endif
03984         };
03985                     ipixel += 1;
03986                     topRLEdata += 1 * voxel_istride;
03987                     botRLEdata += 1 * voxel_istride;
03988                     count--;
03989                     SET_VOXELS_LOADED;
03990                 }
03991                 break;
03992             case BOT_NONZERO__ALL_NONZERO:
03993                 /* first pixel: bottom-left, top-right and bottom-right
03994                    voxels contribute */
03995                 if (!voxels_loaded) {
03996                     
03997     
03998             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03999             opacity = param0_table[opac_param];
04000             if (param1_size != 0) {
04001                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04002                 opacity *= param1_table[opac_param];
04003                 if (param2_size != 0) {
04004                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04005                     opacity *= param2_table[opac_param];
04006                 }
04007             }
04008             if (opacity > min_opacity) {
04009                 opacity_int = opacity*255.;
04010                 bot_opc = opac_correct[opacity_int];
04011             } else {
04012                 bot_opc = (float)0.;
04013             };
04014     
04015     
04016     ;
04017     ;
04018     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
04019     shade_factor = bot_opc * slice_depth_cueing;
04020     
04021         bot_clr *= shade_factor;
04022     ;
04023                 }
04024                 
04025 #ifdef DEBUG
04026     if (ipixel == trace_pixel_ptr) {
04027         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04028         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04029         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04030         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04031         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04032     }
04033 #endif
04034 ;
04035                 
04036        acc_opc = bot_opc * wgtBL;
04037        acc_clr = bot_clr * wgtBL;
04038        
04039 #ifdef DEBUG
04040     if (ipixel == trace_pixel_ptr) {
04041         trace_opcBL = bot_opc;
04042         trace_rclrBL = bot_clr;
04043         
04044     }
04045 #endif
04046 ;
04047                 
04048     
04049             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04050             opacity = param0_table[opac_param];
04051             if (param1_size != 0) {
04052                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04053                 opacity *= param1_table[opac_param];
04054                 if (param2_size != 0) {
04055                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04056                     opacity *= param2_table[opac_param];
04057                 }
04058             }
04059             if (opacity > min_opacity) {
04060                 opacity_int = opacity*255.;
04061                 top_opc = opac_correct[opacity_int];
04062             } else {
04063                 top_opc = (float)0.;
04064             };
04065     
04066     
04067     ;
04068     ;
04069     shade_func(topRLEdata, &(top_clr), client_data);
04070     shade_factor = top_opc * slice_depth_cueing;
04071     
04072         top_clr *= shade_factor;
04073     ;
04074                 
04075     
04076             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04077             opacity = param0_table[opac_param];
04078             if (param1_size != 0) {
04079                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04080                 opacity *= param1_table[opac_param];
04081                 if (param2_size != 0) {
04082                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04083                     opacity *= param2_table[opac_param];
04084                 }
04085             }
04086             if (opacity > min_opacity) {
04087                 opacity_int = opacity*255.;
04088                 bot_opc = opac_correct[opacity_int];
04089             } else {
04090                 bot_opc = (float)0.;
04091             };
04092     
04093     
04094     ;
04095     ;
04096     shade_func(botRLEdata, &(bot_clr), client_data);
04097     shade_factor = bot_opc * slice_depth_cueing;
04098     
04099         bot_clr *= shade_factor;
04100     ;
04101                 
04102        acc_opc += top_opc * wgtTR;
04103        acc_clr += top_clr * wgtTR;
04104        
04105 #ifdef DEBUG
04106     if (ipixel == trace_pixel_ptr) {
04107         trace_opcTR = top_opc;
04108         trace_rclrTR = top_clr;
04109         
04110     }
04111 #endif
04112 ;
04113                 
04114        acc_opc += bot_opc * wgtBR;
04115        acc_clr += bot_clr * wgtBR;
04116        
04117 #ifdef DEBUG
04118     if (ipixel == trace_pixel_ptr) {
04119         trace_opcBR = bot_opc;
04120         trace_rclrBR = bot_clr;
04121         
04122     }
04123 #endif
04124 ;
04125                 
04126         COUNT_RESAMPLE;
04127         if (acc_opc > min_opacity) {
04128             COUNT_COMPOSITE;
04129             iopc = ipixel->opcflt;
04130 #           ifndef SKIP_ERT
04131                 ASSERT(iopc < max_opacity);
04132 #           endif
04133             iopc_inv = (float)1. - iopc;
04134             ipixel->clrflt += acc_clr * iopc_inv;
04135             iopc += acc_opc * iopc_inv;
04136             ipixel->opcflt = iopc;
04137             
04138 #ifdef DEBUG
04139     if (ipixel == trace_pixel_ptr) {
04140 #ifdef COMPUTE_SHADOW_BUFFER
04141         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04142 #else
04143         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04144 #endif
04145         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04146         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04147         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04148         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04149         printf("  %3.0f %3.0f\n", iopc*255., 
04150                ipixel->clrflt);
04151         
04152         
04153     }
04154 #endif /* DEBUG */
04155 ;
04156 #           ifndef SKIP_ERT
04157                 if (iopc >= max_opacity) {
04158                     ASSERT(ipixel->lnk == 0);
04159                     ipixel->lnk = 1;
04160                 }
04161 #           endif
04162         };
04163                 ipixel += 1;
04164                 topRLEdata += 1 * voxel_istride;
04165                 botRLEdata += 1 * voxel_istride;
04166                 count--;
04167                 SET_VOXELS_LOADED;
04168                     
04169                 /* do the rest of the pixels in this run;
04170                    all four voxels contribute */
04171                 while (count > 0) {
04172                     if (PIXEL_IS_OPAQUE(ipixel))
04173                         break;
04174                     if (!voxels_loaded) {
04175                         
04176     
04177             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04178             opacity = param0_table[opac_param];
04179             if (param1_size != 0) {
04180                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04181                 opacity *= param1_table[opac_param];
04182                 if (param2_size != 0) {
04183                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04184                     opacity *= param2_table[opac_param];
04185                 }
04186             }
04187             if (opacity > min_opacity) {
04188                 opacity_int = opacity*255.;
04189                 top_opc = opac_correct[opacity_int];
04190             } else {
04191                 top_opc = (float)0.;
04192             };
04193     
04194     
04195     ;
04196     ;
04197     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
04198     shade_factor = top_opc * slice_depth_cueing;
04199     
04200         top_clr *= shade_factor;
04201     ;
04202                         
04203     
04204             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04205             opacity = param0_table[opac_param];
04206             if (param1_size != 0) {
04207                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04208                 opacity *= param1_table[opac_param];
04209                 if (param2_size != 0) {
04210                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04211                     opacity *= param2_table[opac_param];
04212                 }
04213             }
04214             if (opacity > min_opacity) {
04215                 opacity_int = opacity*255.;
04216                 bot_opc = opac_correct[opacity_int];
04217             } else {
04218                 bot_opc = (float)0.;
04219             };
04220     
04221     
04222     ;
04223     ;
04224     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
04225     shade_factor = bot_opc * slice_depth_cueing;
04226     
04227         bot_clr *= shade_factor;
04228     ;
04229                     }
04230                     
04231 #ifdef DEBUG
04232     if (ipixel == trace_pixel_ptr) {
04233         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04234         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04235         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04236         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04237         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04238     }
04239 #endif
04240 ;
04241                     
04242        acc_opc = top_opc * wgtTL;
04243        acc_clr = top_clr * wgtTL;
04244        
04245 #ifdef DEBUG
04246     if (ipixel == trace_pixel_ptr) {
04247         trace_opcTL = top_opc;
04248         trace_rclrTL = top_clr;
04249         
04250     }
04251 #endif
04252 ;
04253                     
04254        acc_opc += bot_opc * wgtBL;
04255        acc_clr += bot_clr * wgtBL;
04256        
04257 #ifdef DEBUG
04258     if (ipixel == trace_pixel_ptr) {
04259         trace_opcBL = bot_opc;
04260         trace_rclrBL = bot_clr;
04261         
04262     }
04263 #endif
04264 ;
04265                     
04266     
04267             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04268             opacity = param0_table[opac_param];
04269             if (param1_size != 0) {
04270                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04271                 opacity *= param1_table[opac_param];
04272                 if (param2_size != 0) {
04273                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04274                     opacity *= param2_table[opac_param];
04275                 }
04276             }
04277             if (opacity > min_opacity) {
04278                 opacity_int = opacity*255.;
04279                 top_opc = opac_correct[opacity_int];
04280             } else {
04281                 top_opc = (float)0.;
04282             };
04283     
04284     
04285     ;
04286     ;
04287     shade_func(topRLEdata, &(top_clr), client_data);
04288     shade_factor = top_opc * slice_depth_cueing;
04289     
04290         top_clr *= shade_factor;
04291     ;
04292                     
04293     
04294             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04295             opacity = param0_table[opac_param];
04296             if (param1_size != 0) {
04297                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04298                 opacity *= param1_table[opac_param];
04299                 if (param2_size != 0) {
04300                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04301                     opacity *= param2_table[opac_param];
04302                 }
04303             }
04304             if (opacity > min_opacity) {
04305                 opacity_int = opacity*255.;
04306                 bot_opc = opac_correct[opacity_int];
04307             } else {
04308                 bot_opc = (float)0.;
04309             };
04310     
04311     
04312     ;
04313     ;
04314     shade_func(botRLEdata, &(bot_clr), client_data);
04315     shade_factor = bot_opc * slice_depth_cueing;
04316     
04317         bot_clr *= shade_factor;
04318     ;
04319                     
04320        acc_opc += top_opc * wgtTR;
04321        acc_clr += top_clr * wgtTR;
04322        
04323 #ifdef DEBUG
04324     if (ipixel == trace_pixel_ptr) {
04325         trace_opcTR = top_opc;
04326         trace_rclrTR = top_clr;
04327         
04328     }
04329 #endif
04330 ;
04331                     
04332        acc_opc += bot_opc * wgtBR;
04333        acc_clr += bot_clr * wgtBR;
04334        
04335 #ifdef DEBUG
04336     if (ipixel == trace_pixel_ptr) {
04337         trace_opcBR = bot_opc;
04338         trace_rclrBR = bot_clr;
04339         
04340     }
04341 #endif
04342 ;
04343                     
04344         COUNT_RESAMPLE;
04345         if (acc_opc > min_opacity) {
04346             COUNT_COMPOSITE;
04347             iopc = ipixel->opcflt;
04348 #           ifndef SKIP_ERT
04349                 ASSERT(iopc < max_opacity);
04350 #           endif
04351             iopc_inv = (float)1. - iopc;
04352             ipixel->clrflt += acc_clr * iopc_inv;
04353             iopc += acc_opc * iopc_inv;
04354             ipixel->opcflt = iopc;
04355             
04356 #ifdef DEBUG
04357     if (ipixel == trace_pixel_ptr) {
04358 #ifdef COMPUTE_SHADOW_BUFFER
04359         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04360 #else
04361         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04362 #endif
04363         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04364         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04365         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04366         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04367         printf("  %3.0f %3.0f\n", iopc*255., 
04368                ipixel->clrflt);
04369         
04370         
04371     }
04372 #endif /* DEBUG */
04373 ;
04374 #           ifndef SKIP_ERT
04375                 if (iopc >= max_opacity) {
04376                     ASSERT(ipixel->lnk == 0);
04377                     ipixel->lnk = 1;
04378                 }
04379 #           endif
04380         };
04381                     ipixel += 1;
04382                     topRLEdata += 1 * voxel_istride;
04383                     botRLEdata += 1 * voxel_istride;
04384                     count--;
04385                     SET_VOXELS_LOADED;
04386                 }
04387                 break;
04388             case ALL_NONZERO__ALL_NONZERO:
04389                 /* do the pixels in this run; all four voxels contribute */
04390                 while (count > 0) {
04391                     if (PIXEL_IS_OPAQUE(ipixel))
04392                         break;
04393                     if (!voxels_loaded) {
04394                         
04395     
04396             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04397             opacity = param0_table[opac_param];
04398             if (param1_size != 0) {
04399                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04400                 opacity *= param1_table[opac_param];
04401                 if (param2_size != 0) {
04402                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04403                     opacity *= param2_table[opac_param];
04404                 }
04405             }
04406             if (opacity > min_opacity) {
04407                 opacity_int = opacity*255.;
04408                 top_opc = opac_correct[opacity_int];
04409             } else {
04410                 top_opc = (float)0.;
04411             };
04412     
04413     
04414     ;
04415     ;
04416     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
04417     shade_factor = top_opc * slice_depth_cueing;
04418     
04419         top_clr *= shade_factor;
04420     ;
04421                         
04422     
04423             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04424             opacity = param0_table[opac_param];
04425             if (param1_size != 0) {
04426                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04427                 opacity *= param1_table[opac_param];
04428                 if (param2_size != 0) {
04429                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04430                     opacity *= param2_table[opac_param];
04431                 }
04432             }
04433             if (opacity > min_opacity) {
04434                 opacity_int = opacity*255.;
04435                 bot_opc = opac_correct[opacity_int];
04436             } else {
04437                 bot_opc = (float)0.;
04438             };
04439     
04440     
04441     ;
04442     ;
04443     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
04444     shade_factor = bot_opc * slice_depth_cueing;
04445     
04446         bot_clr *= shade_factor;
04447     ;
04448                     }
04449                     
04450 #ifdef DEBUG
04451     if (ipixel == trace_pixel_ptr) {
04452         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04453         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04454         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04455         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04456         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04457     }
04458 #endif
04459 ;
04460                     
04461        acc_opc = top_opc * wgtTL;
04462        acc_clr = top_clr * wgtTL;
04463        
04464 #ifdef DEBUG
04465     if (ipixel == trace_pixel_ptr) {
04466         trace_opcTL = top_opc;
04467         trace_rclrTL = top_clr;
04468         
04469     }
04470 #endif
04471 ;
04472                     
04473        acc_opc += bot_opc * wgtBL;
04474        acc_clr += bot_clr * wgtBL;
04475        
04476 #ifdef DEBUG
04477     if (ipixel == trace_pixel_ptr) {
04478         trace_opcBL = bot_opc;
04479         trace_rclrBL = bot_clr;
04480         
04481     }
04482 #endif
04483 ;
04484                     
04485     
04486             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04487             opacity = param0_table[opac_param];
04488             if (param1_size != 0) {
04489                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04490                 opacity *= param1_table[opac_param];
04491                 if (param2_size != 0) {
04492                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04493                     opacity *= param2_table[opac_param];
04494                 }
04495             }
04496             if (opacity > min_opacity) {
04497                 opacity_int = opacity*255.;
04498                 top_opc = opac_correct[opacity_int];
04499             } else {
04500                 top_opc = (float)0.;
04501             };
04502     
04503     
04504     ;
04505     ;
04506     shade_func(topRLEdata, &(top_clr), client_data);
04507     shade_factor = top_opc * slice_depth_cueing;
04508     
04509         top_clr *= shade_factor;
04510     ;
04511                     
04512     
04513             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04514             opacity = param0_table[opac_param];
04515             if (param1_size != 0) {
04516                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04517                 opacity *= param1_table[opac_param];
04518                 if (param2_size != 0) {
04519                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04520                     opacity *= param2_table[opac_param];
04521                 }
04522             }
04523             if (opacity > min_opacity) {
04524                 opacity_int = opacity*255.;
04525                 bot_opc = opac_correct[opacity_int];
04526             } else {
04527                 bot_opc = (float)0.;
04528             };
04529     
04530     
04531     ;
04532     ;
04533     shade_func(botRLEdata, &(bot_clr), client_data);
04534     shade_factor = bot_opc * slice_depth_cueing;
04535     
04536         bot_clr *= shade_factor;
04537     ;
04538                     
04539        acc_opc += top_opc * wgtTR;
04540        acc_clr += top_clr * wgtTR;
04541        
04542 #ifdef DEBUG
04543     if (ipixel == trace_pixel_ptr) {
04544         trace_opcTR = top_opc;
04545         trace_rclrTR = top_clr;
04546         
04547     }
04548 #endif
04549 ;
04550                     
04551        acc_opc += bot_opc * wgtBR;
04552        acc_clr += bot_clr * wgtBR;
04553        
04554 #ifdef DEBUG
04555     if (ipixel == trace_pixel_ptr) {
04556         trace_opcBR = bot_opc;
04557         trace_rclrBR = bot_clr;
04558         
04559     }
04560 #endif
04561 ;
04562                     
04563         COUNT_RESAMPLE;
04564         if (acc_opc > min_opacity) {
04565             COUNT_COMPOSITE;
04566             iopc = ipixel->opcflt;
04567 #           ifndef SKIP_ERT
04568                 ASSERT(iopc < max_opacity);
04569 #           endif
04570             iopc_inv = (float)1. - iopc;
04571             ipixel->clrflt += acc_clr * iopc_inv;
04572             iopc += acc_opc * iopc_inv;
04573             ipixel->opcflt = iopc;
04574             
04575 #ifdef DEBUG
04576     if (ipixel == trace_pixel_ptr) {
04577 #ifdef COMPUTE_SHADOW_BUFFER
04578         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04579 #else
04580         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04581 #endif
04582         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04583         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04584         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04585         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04586         printf("  %3.0f %3.0f\n", iopc*255., 
04587                ipixel->clrflt);
04588         
04589         
04590     }
04591 #endif /* DEBUG */
04592 ;
04593 #           ifndef SKIP_ERT
04594                 if (iopc >= max_opacity) {
04595                     ASSERT(ipixel->lnk == 0);
04596                     ipixel->lnk = 1;
04597                 }
04598 #           endif
04599         };
04600                     ipixel += 1;
04601                     topRLEdata += 1 * voxel_istride;
04602                     botRLEdata += 1 * voxel_istride;
04603                     count--;
04604                     SET_VOXELS_LOADED;
04605                 }
04606                 break;
04607             default:
04608                 VPBug("illegal value for run states in compositing loop");
04609             }
04610 #else /* UNROLL_RUN_LOOP */
04611             /* this run contains pixels, so process them */
04612             while (count > 0) {
04613                 if (last_run_state == ALL_ZERO && run_state == ALL_ZERO) {
04614                     ipixel += count;
04615                     if (i != -1) {
04616                         topRLEdata += count * voxel_istride;
04617                         botRLEdata += count * voxel_istride;
04618                     }
04619                     count = 0;
04620                     break;
04621                 }
04622                 if (ipixel->lnk != 0)
04623                     break;
04624                 
04625 #ifdef DEBUG
04626     if (ipixel == trace_pixel_ptr) {
04627         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04628         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04629         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04630         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04631         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04632     }
04633 #endif
04634 ;
04635                 
04636        acc_opc = 0;
04637        acc_clr = 0;
04638                 if (last_run_state & TOP_NONZERO) {
04639                     if (!voxels_loaded) {
04640                         
04641     
04642             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04643             opacity = param0_table[opac_param];
04644             if (param1_size != 0) {
04645                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04646                 opacity *= param1_table[opac_param];
04647                 if (param2_size != 0) {
04648                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04649                     opacity *= param2_table[opac_param];
04650                 }
04651             }
04652             if (opacity > min_opacity) {
04653                 opacity_int = opacity*255.;
04654                 top_opc = opac_correct[opacity_int];
04655             } else {
04656                 top_opc = (float)0.;
04657             };
04658     
04659     
04660     ;
04661     ;
04662     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
04663     shade_factor = top_opc * slice_depth_cueing;
04664     
04665         top_clr *= shade_factor;
04666     ;
04667                     }
04668                     
04669        acc_opc += top_opc * wgtTL;
04670        acc_clr += top_clr * wgtTL;
04671        
04672 #ifdef DEBUG
04673     if (ipixel == trace_pixel_ptr) {
04674         trace_opcTL = top_opc;
04675         trace_rclrTL = top_clr;
04676         
04677     }
04678 #endif
04679 ;
04680                 }
04681                 if (last_run_state & BOT_NONZERO) {
04682                     if (!voxels_loaded) {
04683                         
04684     
04685             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04686             opacity = param0_table[opac_param];
04687             if (param1_size != 0) {
04688                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04689                 opacity *= param1_table[opac_param];
04690                 if (param2_size != 0) {
04691                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04692                     opacity *= param2_table[opac_param];
04693                 }
04694             }
04695             if (opacity > min_opacity) {
04696                 opacity_int = opacity*255.;
04697                 bot_opc = opac_correct[opacity_int];
04698             } else {
04699                 bot_opc = (float)0.;
04700             };
04701     
04702     
04703     ;
04704     ;
04705     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
04706     shade_factor = bot_opc * slice_depth_cueing;
04707     
04708         bot_clr *= shade_factor;
04709     ;
04710                     }
04711                     
04712        acc_opc += bot_opc * wgtBL;
04713        acc_clr += bot_clr * wgtBL;
04714        
04715 #ifdef DEBUG
04716     if (ipixel == trace_pixel_ptr) {
04717         trace_opcBL = bot_opc;
04718         trace_rclrBL = bot_clr;
04719         
04720     }
04721 #endif
04722 ;
04723                 }
04724                 if (run_state & TOP_NONZERO) {
04725                     
04726     
04727             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04728             opacity = param0_table[opac_param];
04729             if (param1_size != 0) {
04730                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04731                 opacity *= param1_table[opac_param];
04732                 if (param2_size != 0) {
04733                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04734                     opacity *= param2_table[opac_param];
04735                 }
04736             }
04737             if (opacity > min_opacity) {
04738                 opacity_int = opacity*255.;
04739                 top_opc = opac_correct[opacity_int];
04740             } else {
04741                 top_opc = (float)0.;
04742             };
04743     
04744     
04745     ;
04746     ;
04747     shade_func(topRLEdata, &(top_clr), client_data);
04748     shade_factor = top_opc * slice_depth_cueing;
04749     
04750         top_clr *= shade_factor;
04751     ;
04752                     
04753        acc_opc += top_opc * wgtTR;
04754        acc_clr += top_clr * wgtTR;
04755        
04756 #ifdef DEBUG
04757     if (ipixel == trace_pixel_ptr) {
04758         trace_opcTR = top_opc;
04759         trace_rclrTR = top_clr;
04760         
04761     }
04762 #endif
04763 ;
04764                     topRLEdata += 1 * voxel_istride;
04765                 } else {
04766                     if (i != -1) {
04767                         topRLEdata += 1 * voxel_istride;
04768                     }
04769                 }
04770                 if (run_state & BOT_NONZERO) {
04771                     
04772     
04773             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04774             opacity = param0_table[opac_param];
04775             if (param1_size != 0) {
04776                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04777                 opacity *= param1_table[opac_param];
04778                 if (param2_size != 0) {
04779                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04780                     opacity *= param2_table[opac_param];
04781                 }
04782             }
04783             if (opacity > min_opacity) {
04784                 opacity_int = opacity*255.;
04785                 bot_opc = opac_correct[opacity_int];
04786             } else {
04787                 bot_opc = (float)0.;
04788             };
04789     
04790     
04791     ;
04792     ;
04793     shade_func(botRLEdata, &(bot_clr), client_data);
04794     shade_factor = bot_opc * slice_depth_cueing;
04795     
04796         bot_clr *= shade_factor;
04797     ;
04798                     
04799        acc_opc += bot_opc * wgtBR;
04800        acc_clr += bot_clr * wgtBR;
04801        
04802 #ifdef DEBUG
04803     if (ipixel == trace_pixel_ptr) {
04804         trace_opcBR = bot_opc;
04805         trace_rclrBR = bot_clr;
04806         
04807     }
04808 #endif
04809 ;
04810                     botRLEdata += 1 * voxel_istride;
04811                 } else {
04812                     if (i != -1) {
04813                         botRLEdata += 1 * voxel_istride;
04814                     }
04815                 }
04816                 
04817         COUNT_RESAMPLE;
04818         if (acc_opc > min_opacity) {
04819             COUNT_COMPOSITE;
04820             iopc = ipixel->opcflt;
04821 #           ifndef SKIP_ERT
04822                 ASSERT(iopc < max_opacity);
04823 #           endif
04824             iopc_inv = (float)1. - iopc;
04825             ipixel->clrflt += acc_clr * iopc_inv;
04826             iopc += acc_opc * iopc_inv;
04827             ipixel->opcflt = iopc;
04828             
04829 #ifdef DEBUG
04830     if (ipixel == trace_pixel_ptr) {
04831 #ifdef COMPUTE_SHADOW_BUFFER
04832         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04833 #else
04834         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04835 #endif
04836         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04837         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04838         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04839         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04840         printf("  %3.0f %3.0f\n", iopc*255., 
04841                ipixel->clrflt);
04842         
04843         
04844     }
04845 #endif /* DEBUG */
04846 ;
04847 #           ifndef SKIP_ERT
04848                 if (iopc >= max_opacity) {
04849                     ASSERT(ipixel->lnk == 0);
04850                     ipixel->lnk = 1;
04851                 }
04852 #           endif
04853         };
04854                 ipixel += 1;
04855                 count--;
04856                 SET_VOXELS_LOADED;
04857                 last_run_state = run_state;
04858             }
04859 #endif /* UNROLL_RUN_LOOP */
04860 
04861             GET_HIRES_TIME(vpc, t1);
04862             STORE_HIRES_TIME(vpc, VPTIMER_PROCESS_VOXELS, t0, t1);
04863             COPY_HIRES_TIME(t0, t1);
04864 
04865             if (count > 0) {
04866                 Debug((vpc, VPDEBUG_COMPOSITE, "Backup(%d)\n", count));
04867                 toprun_count += count;
04868                 botrun_count += count;
04869                 i += count;
04870             }
04871 #endif /* SKIP_COMPOSITE */
04872 
04873             /***********************************************************
04874              * Go on to next voxel run.
04875              ***********************************************************/
04876 
04877             last_run_state = run_state;
04878         } /* while (i > 0) */
04879 
04880         /***************************************************************
04881          * Finish processing voxel scanline and go on to next one.
04882          ***************************************************************/
04883 
04884 #ifdef UNROLL_RUN_LOOP
04885         ASSERT(i == 0);
04886 #else
04887         ASSERT(i == -1);
04888 #endif
04889 
04890 #ifndef SKIP_COMPOSITE
04891 #ifdef UNROLL_RUN_LOOP
04892         /* do the last pixel (to the right of the last voxel) */
04893         if (last_run_state != ALL_ZERO && !PIXEL_IS_OPAQUE(ipixel)) {
04894             /* last voxels are nonzero and the pixel is not opaque yet
04895                so there is work to be done */
04896             Debug((vpc, VPDEBUG_COMPOSITE, "Run(1)End\n"));
04897             switch (last_run_state) {
04898             case TOP_NONZERO:
04899                 /* only the top-left voxel contributes */
04900                 if (!voxels_loaded) {
04901                     
04902     
04903             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04904             opacity = param0_table[opac_param];
04905             if (param1_size != 0) {
04906                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04907                 opacity *= param1_table[opac_param];
04908                 if (param2_size != 0) {
04909                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04910                     opacity *= param2_table[opac_param];
04911                 }
04912             }
04913             if (opacity > min_opacity) {
04914                 opacity_int = opacity*255.;
04915                 top_opc = opac_correct[opacity_int];
04916             } else {
04917                 top_opc = (float)0.;
04918             };
04919     
04920     
04921     ;
04922     ;
04923     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
04924     shade_factor = top_opc * slice_depth_cueing;
04925     
04926         top_clr *= shade_factor;
04927     ;
04928                 }
04929                 
04930 #ifdef DEBUG
04931     if (ipixel == trace_pixel_ptr) {
04932         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04933         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04934         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04935         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04936         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04937     }
04938 #endif
04939 ;
04940                 
04941        acc_opc = top_opc * wgtTL;
04942        acc_clr = top_clr * wgtTL;
04943        
04944 #ifdef DEBUG
04945     if (ipixel == trace_pixel_ptr) {
04946         trace_opcTL = top_opc;
04947         trace_rclrTL = top_clr;
04948         
04949     }
04950 #endif
04951 ;
04952                 
04953         COUNT_RESAMPLE;
04954         if (acc_opc > min_opacity) {
04955             COUNT_COMPOSITE;
04956             iopc = ipixel->opcflt;
04957 #           ifndef SKIP_ERT
04958                 ASSERT(iopc < max_opacity);
04959 #           endif
04960             iopc_inv = (float)1. - iopc;
04961             ipixel->clrflt += acc_clr * iopc_inv;
04962             iopc += acc_opc * iopc_inv;
04963             ipixel->opcflt = iopc;
04964             
04965 #ifdef DEBUG
04966     if (ipixel == trace_pixel_ptr) {
04967 #ifdef COMPUTE_SHADOW_BUFFER
04968         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04969 #else
04970         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04971 #endif
04972         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04973         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04974         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04975         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04976         printf("  %3.0f %3.0f\n", iopc*255., 
04977                ipixel->clrflt);
04978         
04979         
04980     }
04981 #endif /* DEBUG */
04982 ;
04983 #           ifndef SKIP_ERT
04984                 if (iopc >= max_opacity) {
04985                     ASSERT(ipixel->lnk == 0);
04986                     ipixel->lnk = 1;
04987                 }
04988 #           endif
04989         };
04990                 break;
04991             case BOT_NONZERO:
04992                 /* only the bottom left voxel contributes */
04993                 if (!voxels_loaded) {
04994                     
04995     
04996             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04997             opacity = param0_table[opac_param];
04998             if (param1_size != 0) {
04999                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
05000                 opacity *= param1_table[opac_param];
05001                 if (param2_size != 0) {
05002                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
05003                     opacity *= param2_table[opac_param];
05004                 }
05005             }
05006             if (opacity > min_opacity) {
05007                 opacity_int = opacity*255.;
05008                 bot_opc = opac_correct[opacity_int];
05009             } else {
05010                 bot_opc = (float)0.;
05011             };
05012     
05013     
05014     ;
05015     ;
05016     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
05017     shade_factor = bot_opc * slice_depth_cueing;
05018     
05019         bot_clr *= shade_factor;
05020     ;
05021                 }
05022                 
05023 #ifdef DEBUG
05024     if (ipixel == trace_pixel_ptr) {
05025         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
05026         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
05027         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
05028         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
05029         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
05030     }
05031 #endif
05032 ;
05033                 
05034        acc_opc = bot_opc * wgtBL;
05035        acc_clr = bot_clr * wgtBL;
05036        
05037 #ifdef DEBUG
05038     if (ipixel == trace_pixel_ptr) {
05039         trace_opcBL = bot_opc;
05040         trace_rclrBL = bot_clr;
05041         
05042     }
05043 #endif
05044 ;
05045                 
05046         COUNT_RESAMPLE;
05047         if (acc_opc > min_opacity) {
05048             COUNT_COMPOSITE;
05049             iopc = ipixel->opcflt;
05050 #           ifndef SKIP_ERT
05051                 ASSERT(iopc < max_opacity);
05052 #           endif
05053             iopc_inv = (float)1. - iopc;
05054             ipixel->clrflt += acc_clr * iopc_inv;
05055             iopc += acc_opc * iopc_inv;
05056             ipixel->opcflt = iopc;
05057             
05058 #ifdef DEBUG
05059     if (ipixel == trace_pixel_ptr) {
05060 #ifdef COMPUTE_SHADOW_BUFFER
05061         printf("{%3d}  %3d %3d", k, icount-i-count, j);
05062 #else
05063         printf("[%3d]  %3d %3d", k, icount-i-count, j);
05064 #endif
05065         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
05066         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
05067         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
05068         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
05069         printf("  %3.0f %3.0f\n", iopc*255., 
05070                ipixel->clrflt);
05071         
05072         
05073     }
05074 #endif /* DEBUG */
05075 ;
05076 #           ifndef SKIP_ERT
05077                 if (iopc >= max_opacity) {
05078                     ASSERT(ipixel->lnk == 0);
05079                     ipixel->lnk = 1;
05080                 }
05081 #           endif
05082         };
05083                 break;
05084             case ALL_NONZERO:
05085                 /* the top and bottom left voxels contribute */
05086                 if (!voxels_loaded) {
05087                     
05088     
05089             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
05090             opacity = param0_table[opac_param];
05091             if (param1_size != 0) {
05092                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
05093                 opacity *= param1_table[opac_param];
05094                 if (param2_size != 0) {
05095                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
05096                     opacity *= param2_table[opac_param];
05097                 }
05098             }
05099             if (opacity > min_opacity) {
05100                 opacity_int = opacity*255.;
05101                 top_opc = opac_correct[opacity_int];
05102             } else {
05103                 top_opc = (float)0.;
05104             };
05105     
05106     
05107     ;
05108     ;
05109     shade_func(topRLEdata - voxel_istride, &(top_clr), client_data);
05110     shade_factor = top_opc * slice_depth_cueing;
05111     
05112         top_clr *= shade_factor;
05113     ;
05114                     
05115     
05116             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
05117             opacity = param0_table[opac_param];
05118             if (param1_size != 0) {
05119                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
05120                 opacity *= param1_table[opac_param];
05121                 if (param2_size != 0) {
05122                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
05123                     opacity *= param2_table[opac_param];
05124                 }
05125             }
05126             if (opacity > min_opacity) {
05127                 opacity_int = opacity*255.;
05128                 bot_opc = opac_correct[opacity_int];
05129             } else {
05130                 bot_opc = (float)0.;
05131             };
05132     
05133     
05134     ;
05135     ;
05136     shade_func(botRLEdata - voxel_istride, &(bot_clr), client_data);
05137     shade_factor = bot_opc * slice_depth_cueing;
05138     
05139         bot_clr *= shade_factor;
05140     ;
05141                 }
05142                 
05143 #ifdef DEBUG
05144     if (ipixel == trace_pixel_ptr) {
05145         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
05146         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
05147         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
05148         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
05149         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
05150     }
05151 #endif
05152 ;
05153                 
05154        acc_opc = top_opc * wgtTL;
05155        acc_clr = top_clr * wgtTL;
05156        
05157 #ifdef DEBUG
05158     if (ipixel == trace_pixel_ptr) {
05159         trace_opcTL = top_opc;
05160         trace_rclrTL = top_clr;
05161         
05162     }
05163 #endif
05164 ;
05165                 
05166        acc_opc += bot_opc * wgtBL;
05167        acc_clr += bot_clr * wgtBL;
05168        
05169 #ifdef DEBUG
05170     if (ipixel == trace_pixel_ptr) {
05171         trace_opcBL = bot_opc;
05172         trace_rclrBL = bot_clr;
05173         
05174     }
05175 #endif
05176 ;
05177                 
05178         COUNT_RESAMPLE;
05179         if (acc_opc > min_opacity) {
05180             COUNT_COMPOSITE;
05181             iopc = ipixel->opcflt;
05182 #           ifndef SKIP_ERT
05183                 ASSERT(iopc < max_opacity);
05184 #           endif
05185             iopc_inv = (float)1. - iopc;
05186             ipixel->clrflt += acc_clr * iopc_inv;
05187             iopc += acc_opc * iopc_inv;
05188             ipixel->opcflt = iopc;
05189             
05190 #ifdef DEBUG
05191     if (ipixel == trace_pixel_ptr) {
05192 #ifdef COMPUTE_SHADOW_BUFFER
05193         printf("{%3d}  %3d %3d", k, icount-i-count, j);
05194 #else
05195         printf("[%3d]  %3d %3d", k, icount-i-count, j);
05196 #endif
05197         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
05198         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
05199         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
05200         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
05201         printf("  %3.0f %3.0f\n", iopc*255., 
05202                ipixel->clrflt);
05203         
05204         
05205     }
05206 #endif /* DEBUG */
05207 ;
05208 #           ifndef SKIP_ERT
05209                 if (iopc >= max_opacity) {
05210                     ASSERT(ipixel->lnk == 0);
05211                     ipixel->lnk = 1;
05212                 }
05213 #           endif
05214         };
05215                 break;
05216             default:
05217                 VPBug("illegal value for run state at end of scanline");
05218             }
05219         } else if (last_run_state == ALL_ZERO) {
05220             Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
05221         } else {
05222             Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
05223         }
05224 #endif /* UNROLL_RUN_LOOP */
05225 #endif /* SKIP_COMPOSITE */
05226 
05227 #ifndef UNROLL_RUN_LOOP
05228         run_state = final_run_state;
05229 #endif
05230         /* skip over any zero-length runs remaining in this scanline */
05231         if (j != 0 && ((run_state & 1) == 0)) {
05232             toprun_count = *topRLElen++;
05233             ASSERT(toprun_count == 0);
05234         }
05235         if (j != jcount && ((run_state & 2) == 0)) {
05236             botrun_count = *botRLElen++;
05237             ASSERT(botrun_count == 0);
05238         }
05239 
05240         /* go to next intermediate image scanline */
05241 #ifdef UNROLL_RUN_LOOP
05242         ipixel += intermediate_width - icount;
05243 #ifdef USE_SHADOW_BUFFER
05244         shadow_pixel += shadow_width - icount;
05245 #endif
05246 #else /* UNROLL_RUN_LOOP */
05247         ipixel += intermediate_width - (icount+1);
05248 #ifdef USE_SHADOW_BUFFER
05249         shadow_pixel += shadow_width - (icount+1);
05250 #endif
05251 #endif /* UNROLL_RUN_LOOP */
05252 
05253         Debug((vpc, VPDEBUG_COMPOSITE, "ScanDone\n"));
05254     } /* for j */
05255 
05256     /***************************************************************
05257      * Finish processing the voxel slice.
05258      ***************************************************************/
05259 
05260     GET_HIRES_TIME(vpc, t1);
05261     STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
05262 
05263     Debug((vpc, VPDEBUG_COMPOSITE, "SliceDone\n"));
05264 }
AFNI/NIfTI Server

Sections

Personal tools

Navigation

Doxygen Source Code Documentation

vp_compAR1PB.c
