Doxygen Source Code Documentation

Main Page Alphabetical List Data Structures File List Data Fields Globals Search
vp_compAR00G.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:21 $
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 #define COMPUTE_SHADOW_BUFFER
00070     
00071 
00072 
00073 
00074 
00075 
00076 
00077 
00078 
00079 
00080 
00081 
00082 
00083 
00084 
00085 
00086 
00087 
00088 
00089 
00090 
00091 
00092 
00093 
00094 #define MULTIPLE_MATERIALS
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     
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  * VPCompAR00G
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 VPCompAR00G (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 #ifdef DEBUG
00985     if (ipixel == trace_pixel_ptr) {
00986         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
00987         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
00988         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
00989         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
00990         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
00991     }
00992 #endif
00993 ;
00994                 
00995        acc_opc = top_opc * wgtTL;
00996        ;
00997        
00998 #ifdef DEBUG
00999     if (ipixel == trace_pixel_ptr) {
01000         trace_opcTL = top_opc;
01001         
01002         
01003     }
01004 #endif
01005 ;
01006                 
01007         COUNT_RESAMPLE;
01008         if (acc_opc > min_opacity) {
01009             COUNT_COMPOSITE;
01010             iopc = ipixel->opcflt;
01011 #           ifndef SKIP_ERT
01012                 ASSERT(iopc < max_opacity);
01013 #           endif
01014             iopc_inv = (float)1. - iopc;
01015             ;
01016             iopc += acc_opc * iopc_inv;
01017             ipixel->opcflt = iopc;
01018             
01019 #ifdef DEBUG
01020     if (ipixel == trace_pixel_ptr) {
01021 #ifdef COMPUTE_SHADOW_BUFFER
01022         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01023 #else
01024         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01025 #endif
01026         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01027         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01028         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01029         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01030         printf("  %3.0f %3.0f\n", iopc*255., 
01031                0);
01032         
01033         
01034     }
01035 #endif /* DEBUG */
01036 ;
01037 #           ifndef SKIP_ERT
01038                 if (iopc >= max_opacity) {
01039                     ASSERT(ipixel->lnk == 0);
01040                     ipixel->lnk = 1;
01041                 }
01042 #           endif
01043         };
01044                 ipixel += count;
01045                 topRLEdata += count * voxel_istride;
01046                 botRLEdata += count * voxel_istride;
01047                 count = 0;
01048                 break;
01049             case BOT_NONZERO__ALL_ZERO:
01050                 /* only the bottom left voxel contributes to the first
01051                    pixel of the run, and the rest are zero */
01052                 if (!voxels_loaded) {
01053                     
01054     
01055             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01056             opacity = param0_table[opac_param];
01057             if (param1_size != 0) {
01058                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01059                 opacity *= param1_table[opac_param];
01060                 if (param2_size != 0) {
01061                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01062                     opacity *= param2_table[opac_param];
01063                 }
01064             }
01065             if (opacity > min_opacity) {
01066                 opacity_int = opacity*255.;
01067                 bot_opc = opac_correct[opacity_int];
01068             } else {
01069                 bot_opc = (float)0.;
01070             };
01071     
01072     ;
01073                 }
01074                 
01075 #ifdef DEBUG
01076     if (ipixel == trace_pixel_ptr) {
01077         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01078         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01079         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01080         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01081         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01082     }
01083 #endif
01084 ;
01085                 
01086        acc_opc = bot_opc * wgtBL;
01087        ;
01088        
01089 #ifdef DEBUG
01090     if (ipixel == trace_pixel_ptr) {
01091         trace_opcBL = bot_opc;
01092         
01093         
01094     }
01095 #endif
01096 ;
01097                 
01098         COUNT_RESAMPLE;
01099         if (acc_opc > min_opacity) {
01100             COUNT_COMPOSITE;
01101             iopc = ipixel->opcflt;
01102 #           ifndef SKIP_ERT
01103                 ASSERT(iopc < max_opacity);
01104 #           endif
01105             iopc_inv = (float)1. - iopc;
01106             ;
01107             iopc += acc_opc * iopc_inv;
01108             ipixel->opcflt = iopc;
01109             
01110 #ifdef DEBUG
01111     if (ipixel == trace_pixel_ptr) {
01112 #ifdef COMPUTE_SHADOW_BUFFER
01113         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01114 #else
01115         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01116 #endif
01117         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01118         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01119         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01120         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01121         printf("  %3.0f %3.0f\n", iopc*255., 
01122                0);
01123         
01124         
01125     }
01126 #endif /* DEBUG */
01127 ;
01128 #           ifndef SKIP_ERT
01129                 if (iopc >= max_opacity) {
01130                     ASSERT(ipixel->lnk == 0);
01131                     ipixel->lnk = 1;
01132                 }
01133 #           endif
01134         };
01135                 ipixel += count;
01136                 topRLEdata += count * voxel_istride;
01137                 botRLEdata += count * voxel_istride;
01138                 count = 0;
01139                 break;
01140             case ALL_NONZERO__ALL_ZERO:
01141                 /* the top and bottom left voxels contribute to the
01142                    first pixel of the run, and the rest are zero */
01143                 if (!voxels_loaded) {
01144                     
01145     
01146             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01147             opacity = param0_table[opac_param];
01148             if (param1_size != 0) {
01149                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01150                 opacity *= param1_table[opac_param];
01151                 if (param2_size != 0) {
01152                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01153                     opacity *= param2_table[opac_param];
01154                 }
01155             }
01156             if (opacity > min_opacity) {
01157                 opacity_int = opacity*255.;
01158                 top_opc = opac_correct[opacity_int];
01159             } else {
01160                 top_opc = (float)0.;
01161             };
01162     
01163     ;
01164                     
01165     
01166             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01167             opacity = param0_table[opac_param];
01168             if (param1_size != 0) {
01169                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01170                 opacity *= param1_table[opac_param];
01171                 if (param2_size != 0) {
01172                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01173                     opacity *= param2_table[opac_param];
01174                 }
01175             }
01176             if (opacity > min_opacity) {
01177                 opacity_int = opacity*255.;
01178                 bot_opc = opac_correct[opacity_int];
01179             } else {
01180                 bot_opc = (float)0.;
01181             };
01182     
01183     ;
01184                 }
01185                 
01186 #ifdef DEBUG
01187     if (ipixel == trace_pixel_ptr) {
01188         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01189         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01190         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01191         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01192         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01193     }
01194 #endif
01195 ;
01196                 
01197        acc_opc = top_opc * wgtTL;
01198        ;
01199        
01200 #ifdef DEBUG
01201     if (ipixel == trace_pixel_ptr) {
01202         trace_opcTL = top_opc;
01203         
01204         
01205     }
01206 #endif
01207 ;
01208                 
01209        acc_opc += bot_opc * wgtBL;
01210        ;
01211        
01212 #ifdef DEBUG
01213     if (ipixel == trace_pixel_ptr) {
01214         trace_opcBL = bot_opc;
01215         
01216         
01217     }
01218 #endif
01219 ;
01220                 
01221         COUNT_RESAMPLE;
01222         if (acc_opc > min_opacity) {
01223             COUNT_COMPOSITE;
01224             iopc = ipixel->opcflt;
01225 #           ifndef SKIP_ERT
01226                 ASSERT(iopc < max_opacity);
01227 #           endif
01228             iopc_inv = (float)1. - iopc;
01229             ;
01230             iopc += acc_opc * iopc_inv;
01231             ipixel->opcflt = iopc;
01232             
01233 #ifdef DEBUG
01234     if (ipixel == trace_pixel_ptr) {
01235 #ifdef COMPUTE_SHADOW_BUFFER
01236         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01237 #else
01238         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01239 #endif
01240         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01241         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01242         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01243         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01244         printf("  %3.0f %3.0f\n", iopc*255., 
01245                0);
01246         
01247         
01248     }
01249 #endif /* DEBUG */
01250 ;
01251 #           ifndef SKIP_ERT
01252                 if (iopc >= max_opacity) {
01253                     ASSERT(ipixel->lnk == 0);
01254                     ipixel->lnk = 1;
01255                 }
01256 #           endif
01257         };
01258                 ipixel += count;
01259                 topRLEdata += count * voxel_istride;
01260                 botRLEdata += count * voxel_istride;
01261                 count = 0;
01262                 break;
01263             case ALL_ZERO__TOP_NONZERO:
01264                 /* first pixel: only the top-right voxel contributes */
01265                 
01266     
01267             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01268             opacity = param0_table[opac_param];
01269             if (param1_size != 0) {
01270                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01271                 opacity *= param1_table[opac_param];
01272                 if (param2_size != 0) {
01273                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01274                     opacity *= param2_table[opac_param];
01275                 }
01276             }
01277             if (opacity > min_opacity) {
01278                 opacity_int = opacity*255.;
01279                 top_opc = opac_correct[opacity_int];
01280             } else {
01281                 top_opc = (float)0.;
01282             };
01283     
01284     ;
01285                 
01286 #ifdef DEBUG
01287     if (ipixel == trace_pixel_ptr) {
01288         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01289         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01290         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01291         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01292         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01293     }
01294 #endif
01295 ;
01296                 
01297        acc_opc = top_opc * wgtTR;
01298        ;
01299        
01300 #ifdef DEBUG
01301     if (ipixel == trace_pixel_ptr) {
01302         trace_opcTR = top_opc;
01303         
01304         
01305     }
01306 #endif
01307 ;
01308                 
01309         COUNT_RESAMPLE;
01310         if (acc_opc > min_opacity) {
01311             COUNT_COMPOSITE;
01312             iopc = ipixel->opcflt;
01313 #           ifndef SKIP_ERT
01314                 ASSERT(iopc < max_opacity);
01315 #           endif
01316             iopc_inv = (float)1. - iopc;
01317             ;
01318             iopc += acc_opc * iopc_inv;
01319             ipixel->opcflt = iopc;
01320             
01321 #ifdef DEBUG
01322     if (ipixel == trace_pixel_ptr) {
01323 #ifdef COMPUTE_SHADOW_BUFFER
01324         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01325 #else
01326         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01327 #endif
01328         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01329         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01330         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01331         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01332         printf("  %3.0f %3.0f\n", iopc*255., 
01333                0);
01334         
01335         
01336     }
01337 #endif /* DEBUG */
01338 ;
01339 #           ifndef SKIP_ERT
01340                 if (iopc >= max_opacity) {
01341                     ASSERT(ipixel->lnk == 0);
01342                     ipixel->lnk = 1;
01343                 }
01344 #           endif
01345         };
01346                 ipixel += 1;
01347                 topRLEdata += 1 * voxel_istride;
01348                 botRLEdata += 1 * voxel_istride;
01349                 count--;
01350                 SET_VOXELS_LOADED;
01351 
01352                 /* do the rest of the pixels in this run;
01353                    the top-left and top-right voxels contribute */
01354                 while (count > 0) {
01355                     if (PIXEL_IS_OPAQUE(ipixel))
01356                         break;
01357                     if (!voxels_loaded) {
01358                         
01359     
01360             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01361             opacity = param0_table[opac_param];
01362             if (param1_size != 0) {
01363                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01364                 opacity *= param1_table[opac_param];
01365                 if (param2_size != 0) {
01366                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01367                     opacity *= param2_table[opac_param];
01368                 }
01369             }
01370             if (opacity > min_opacity) {
01371                 opacity_int = opacity*255.;
01372                 top_opc = opac_correct[opacity_int];
01373             } else {
01374                 top_opc = (float)0.;
01375             };
01376     
01377     ;
01378                     }
01379                     
01380 #ifdef DEBUG
01381     if (ipixel == trace_pixel_ptr) {
01382         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01383         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01384         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01385         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01386         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01387     }
01388 #endif
01389 ;
01390                     
01391        acc_opc = top_opc * wgtTL;
01392        ;
01393        
01394 #ifdef DEBUG
01395     if (ipixel == trace_pixel_ptr) {
01396         trace_opcTL = top_opc;
01397         
01398         
01399     }
01400 #endif
01401 ;
01402                     
01403     
01404             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01405             opacity = param0_table[opac_param];
01406             if (param1_size != 0) {
01407                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01408                 opacity *= param1_table[opac_param];
01409                 if (param2_size != 0) {
01410                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01411                     opacity *= param2_table[opac_param];
01412                 }
01413             }
01414             if (opacity > min_opacity) {
01415                 opacity_int = opacity*255.;
01416                 top_opc = opac_correct[opacity_int];
01417             } else {
01418                 top_opc = (float)0.;
01419             };
01420     
01421     ;
01422                     
01423        acc_opc += top_opc * wgtTR;
01424        ;
01425        
01426 #ifdef DEBUG
01427     if (ipixel == trace_pixel_ptr) {
01428         trace_opcTR = top_opc;
01429         
01430         
01431     }
01432 #endif
01433 ;
01434                     
01435         COUNT_RESAMPLE;
01436         if (acc_opc > min_opacity) {
01437             COUNT_COMPOSITE;
01438             iopc = ipixel->opcflt;
01439 #           ifndef SKIP_ERT
01440                 ASSERT(iopc < max_opacity);
01441 #           endif
01442             iopc_inv = (float)1. - iopc;
01443             ;
01444             iopc += acc_opc * iopc_inv;
01445             ipixel->opcflt = iopc;
01446             
01447 #ifdef DEBUG
01448     if (ipixel == trace_pixel_ptr) {
01449 #ifdef COMPUTE_SHADOW_BUFFER
01450         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01451 #else
01452         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01453 #endif
01454         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01455         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01456         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01457         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01458         printf("  %3.0f %3.0f\n", iopc*255., 
01459                0);
01460         
01461         
01462     }
01463 #endif /* DEBUG */
01464 ;
01465 #           ifndef SKIP_ERT
01466                 if (iopc >= max_opacity) {
01467                     ASSERT(ipixel->lnk == 0);
01468                     ipixel->lnk = 1;
01469                 }
01470 #           endif
01471         };
01472                     ipixel += 1;
01473                     topRLEdata += 1 * voxel_istride;
01474                     botRLEdata += 1 * voxel_istride;
01475                     count--;
01476                     SET_VOXELS_LOADED;
01477                 }
01478                 break;
01479             case TOP_NONZERO__TOP_NONZERO:
01480                 /* do the pixels in this run; the top-left and
01481                    top-right voxels contribute */
01482                 while (count > 0) {
01483                     if (PIXEL_IS_OPAQUE(ipixel))
01484                         break;
01485                     if (!voxels_loaded) {
01486                         
01487     
01488             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01489             opacity = param0_table[opac_param];
01490             if (param1_size != 0) {
01491                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01492                 opacity *= param1_table[opac_param];
01493                 if (param2_size != 0) {
01494                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01495                     opacity *= param2_table[opac_param];
01496                 }
01497             }
01498             if (opacity > min_opacity) {
01499                 opacity_int = opacity*255.;
01500                 top_opc = opac_correct[opacity_int];
01501             } else {
01502                 top_opc = (float)0.;
01503             };
01504     
01505     ;
01506                     }
01507                     
01508 #ifdef DEBUG
01509     if (ipixel == trace_pixel_ptr) {
01510         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01511         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01512         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01513         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01514         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01515     }
01516 #endif
01517 ;
01518                     
01519        acc_opc = top_opc * wgtTL;
01520        ;
01521        
01522 #ifdef DEBUG
01523     if (ipixel == trace_pixel_ptr) {
01524         trace_opcTL = top_opc;
01525         
01526         
01527     }
01528 #endif
01529 ;
01530                     
01531     
01532             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01533             opacity = param0_table[opac_param];
01534             if (param1_size != 0) {
01535                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01536                 opacity *= param1_table[opac_param];
01537                 if (param2_size != 0) {
01538                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01539                     opacity *= param2_table[opac_param];
01540                 }
01541             }
01542             if (opacity > min_opacity) {
01543                 opacity_int = opacity*255.;
01544                 top_opc = opac_correct[opacity_int];
01545             } else {
01546                 top_opc = (float)0.;
01547             };
01548     
01549     ;
01550                     
01551        acc_opc += top_opc * wgtTR;
01552        ;
01553        
01554 #ifdef DEBUG
01555     if (ipixel == trace_pixel_ptr) {
01556         trace_opcTR = top_opc;
01557         
01558         
01559     }
01560 #endif
01561 ;
01562                     
01563         COUNT_RESAMPLE;
01564         if (acc_opc > min_opacity) {
01565             COUNT_COMPOSITE;
01566             iopc = ipixel->opcflt;
01567 #           ifndef SKIP_ERT
01568                 ASSERT(iopc < max_opacity);
01569 #           endif
01570             iopc_inv = (float)1. - iopc;
01571             ;
01572             iopc += acc_opc * iopc_inv;
01573             ipixel->opcflt = iopc;
01574             
01575 #ifdef DEBUG
01576     if (ipixel == trace_pixel_ptr) {
01577 #ifdef COMPUTE_SHADOW_BUFFER
01578         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01579 #else
01580         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01581 #endif
01582         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01583         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01584         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01585         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01586         printf("  %3.0f %3.0f\n", iopc*255., 
01587                0);
01588         
01589         
01590     }
01591 #endif /* DEBUG */
01592 ;
01593 #           ifndef SKIP_ERT
01594                 if (iopc >= max_opacity) {
01595                     ASSERT(ipixel->lnk == 0);
01596                     ipixel->lnk = 1;
01597                 }
01598 #           endif
01599         };
01600                     ipixel += 1;
01601                     topRLEdata += 1 * voxel_istride;
01602                     botRLEdata += 1 * voxel_istride;
01603                     count--;
01604                     SET_VOXELS_LOADED;
01605                 }
01606                 break;
01607             case BOT_NONZERO__TOP_NONZERO:
01608                 /* first pixel: bottom-left and top-right voxels
01609                    contribute */
01610                 if (!voxels_loaded) {
01611                     
01612     
01613             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01614             opacity = param0_table[opac_param];
01615             if (param1_size != 0) {
01616                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01617                 opacity *= param1_table[opac_param];
01618                 if (param2_size != 0) {
01619                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01620                     opacity *= param2_table[opac_param];
01621                 }
01622             }
01623             if (opacity > min_opacity) {
01624                 opacity_int = opacity*255.;
01625                 bot_opc = opac_correct[opacity_int];
01626             } else {
01627                 bot_opc = (float)0.;
01628             };
01629     
01630     ;
01631                 }
01632                 
01633 #ifdef DEBUG
01634     if (ipixel == trace_pixel_ptr) {
01635         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01636         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01637         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01638         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01639         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01640     }
01641 #endif
01642 ;
01643                 
01644        acc_opc = bot_opc * wgtBL;
01645        ;
01646        
01647 #ifdef DEBUG
01648     if (ipixel == trace_pixel_ptr) {
01649         trace_opcBL = bot_opc;
01650         
01651         
01652     }
01653 #endif
01654 ;
01655                 
01656     
01657             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01658             opacity = param0_table[opac_param];
01659             if (param1_size != 0) {
01660                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01661                 opacity *= param1_table[opac_param];
01662                 if (param2_size != 0) {
01663                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01664                     opacity *= param2_table[opac_param];
01665                 }
01666             }
01667             if (opacity > min_opacity) {
01668                 opacity_int = opacity*255.;
01669                 top_opc = opac_correct[opacity_int];
01670             } else {
01671                 top_opc = (float)0.;
01672             };
01673     
01674     ;
01675                 
01676        acc_opc += top_opc * wgtTR;
01677        ;
01678        
01679 #ifdef DEBUG
01680     if (ipixel == trace_pixel_ptr) {
01681         trace_opcTR = top_opc;
01682         
01683         
01684     }
01685 #endif
01686 ;
01687                 
01688         COUNT_RESAMPLE;
01689         if (acc_opc > min_opacity) {
01690             COUNT_COMPOSITE;
01691             iopc = ipixel->opcflt;
01692 #           ifndef SKIP_ERT
01693                 ASSERT(iopc < max_opacity);
01694 #           endif
01695             iopc_inv = (float)1. - iopc;
01696             ;
01697             iopc += acc_opc * iopc_inv;
01698             ipixel->opcflt = iopc;
01699             
01700 #ifdef DEBUG
01701     if (ipixel == trace_pixel_ptr) {
01702 #ifdef COMPUTE_SHADOW_BUFFER
01703         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01704 #else
01705         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01706 #endif
01707         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01708         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01709         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01710         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01711         printf("  %3.0f %3.0f\n", iopc*255., 
01712                0);
01713         
01714         
01715     }
01716 #endif /* DEBUG */
01717 ;
01718 #           ifndef SKIP_ERT
01719                 if (iopc >= max_opacity) {
01720                     ASSERT(ipixel->lnk == 0);
01721                     ipixel->lnk = 1;
01722                 }
01723 #           endif
01724         };
01725                 ipixel += 1;
01726                 topRLEdata += 1 * voxel_istride;
01727                 botRLEdata += 1 * voxel_istride;
01728                 count--;
01729                 SET_VOXELS_LOADED;
01730 
01731                 /* do the rest of the pixels in this run;
01732                    the top-left and top-right voxels contribute */
01733                 while (count > 0) {
01734                     if (PIXEL_IS_OPAQUE(ipixel))
01735                         break;
01736                     if (!voxels_loaded) {
01737                         
01738     
01739             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01740             opacity = param0_table[opac_param];
01741             if (param1_size != 0) {
01742                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01743                 opacity *= param1_table[opac_param];
01744                 if (param2_size != 0) {
01745                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01746                     opacity *= param2_table[opac_param];
01747                 }
01748             }
01749             if (opacity > min_opacity) {
01750                 opacity_int = opacity*255.;
01751                 top_opc = opac_correct[opacity_int];
01752             } else {
01753                 top_opc = (float)0.;
01754             };
01755     
01756     ;
01757                     }
01758                     
01759 #ifdef DEBUG
01760     if (ipixel == trace_pixel_ptr) {
01761         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01762         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01763         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01764         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01765         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01766     }
01767 #endif
01768 ;
01769                     
01770        acc_opc = top_opc * wgtTL;
01771        ;
01772        
01773 #ifdef DEBUG
01774     if (ipixel == trace_pixel_ptr) {
01775         trace_opcTL = top_opc;
01776         
01777         
01778     }
01779 #endif
01780 ;
01781                     
01782     
01783             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01784             opacity = param0_table[opac_param];
01785             if (param1_size != 0) {
01786                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01787                 opacity *= param1_table[opac_param];
01788                 if (param2_size != 0) {
01789                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01790                     opacity *= param2_table[opac_param];
01791                 }
01792             }
01793             if (opacity > min_opacity) {
01794                 opacity_int = opacity*255.;
01795                 top_opc = opac_correct[opacity_int];
01796             } else {
01797                 top_opc = (float)0.;
01798             };
01799     
01800     ;
01801                     
01802        acc_opc += top_opc * wgtTR;
01803        ;
01804        
01805 #ifdef DEBUG
01806     if (ipixel == trace_pixel_ptr) {
01807         trace_opcTR = top_opc;
01808         
01809         
01810     }
01811 #endif
01812 ;
01813                     
01814         COUNT_RESAMPLE;
01815         if (acc_opc > min_opacity) {
01816             COUNT_COMPOSITE;
01817             iopc = ipixel->opcflt;
01818 #           ifndef SKIP_ERT
01819                 ASSERT(iopc < max_opacity);
01820 #           endif
01821             iopc_inv = (float)1. - iopc;
01822             ;
01823             iopc += acc_opc * iopc_inv;
01824             ipixel->opcflt = iopc;
01825             
01826 #ifdef DEBUG
01827     if (ipixel == trace_pixel_ptr) {
01828 #ifdef COMPUTE_SHADOW_BUFFER
01829         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01830 #else
01831         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01832 #endif
01833         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01834         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01835         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01836         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01837         printf("  %3.0f %3.0f\n", iopc*255., 
01838                0);
01839         
01840         
01841     }
01842 #endif /* DEBUG */
01843 ;
01844 #           ifndef SKIP_ERT
01845                 if (iopc >= max_opacity) {
01846                     ASSERT(ipixel->lnk == 0);
01847                     ipixel->lnk = 1;
01848                 }
01849 #           endif
01850         };
01851                     ipixel += 1;
01852                     topRLEdata += 1 * voxel_istride;
01853                     botRLEdata += 1 * voxel_istride;
01854                     count--;
01855                     SET_VOXELS_LOADED;
01856                 }
01857                 break;
01858             case ALL_NONZERO__TOP_NONZERO:
01859                 /* first pixel: top-left, bottom-left and top-right voxels
01860                    contribute */
01861                 if (!voxels_loaded) {
01862                     
01863     
01864             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01865             opacity = param0_table[opac_param];
01866             if (param1_size != 0) {
01867                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01868                 opacity *= param1_table[opac_param];
01869                 if (param2_size != 0) {
01870                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01871                     opacity *= param2_table[opac_param];
01872                 }
01873             }
01874             if (opacity > min_opacity) {
01875                 opacity_int = opacity*255.;
01876                 top_opc = opac_correct[opacity_int];
01877             } else {
01878                 top_opc = (float)0.;
01879             };
01880     
01881     ;
01882                     
01883     
01884             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01885             opacity = param0_table[opac_param];
01886             if (param1_size != 0) {
01887                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01888                 opacity *= param1_table[opac_param];
01889                 if (param2_size != 0) {
01890                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01891                     opacity *= param2_table[opac_param];
01892                 }
01893             }
01894             if (opacity > min_opacity) {
01895                 opacity_int = opacity*255.;
01896                 bot_opc = opac_correct[opacity_int];
01897             } else {
01898                 bot_opc = (float)0.;
01899             };
01900     
01901     ;
01902                 }
01903                 
01904 #ifdef DEBUG
01905     if (ipixel == trace_pixel_ptr) {
01906         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01907         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01908         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01909         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01910         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01911     }
01912 #endif
01913 ;
01914                 
01915        acc_opc = top_opc * wgtTL;
01916        ;
01917        
01918 #ifdef DEBUG
01919     if (ipixel == trace_pixel_ptr) {
01920         trace_opcTL = top_opc;
01921         
01922         
01923     }
01924 #endif
01925 ;
01926                 
01927        acc_opc += bot_opc * wgtBL;
01928        ;
01929        
01930 #ifdef DEBUG
01931     if (ipixel == trace_pixel_ptr) {
01932         trace_opcBL = bot_opc;
01933         
01934         
01935     }
01936 #endif
01937 ;
01938                 
01939     
01940             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01941             opacity = param0_table[opac_param];
01942             if (param1_size != 0) {
01943                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01944                 opacity *= param1_table[opac_param];
01945                 if (param2_size != 0) {
01946                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01947                     opacity *= param2_table[opac_param];
01948                 }
01949             }
01950             if (opacity > min_opacity) {
01951                 opacity_int = opacity*255.;
01952                 top_opc = opac_correct[opacity_int];
01953             } else {
01954                 top_opc = (float)0.;
01955             };
01956     
01957     ;
01958                 
01959        acc_opc += top_opc * wgtTR;
01960        ;
01961        
01962 #ifdef DEBUG
01963     if (ipixel == trace_pixel_ptr) {
01964         trace_opcTR = top_opc;
01965         
01966         
01967     }
01968 #endif
01969 ;
01970                 
01971         COUNT_RESAMPLE;
01972         if (acc_opc > min_opacity) {
01973             COUNT_COMPOSITE;
01974             iopc = ipixel->opcflt;
01975 #           ifndef SKIP_ERT
01976                 ASSERT(iopc < max_opacity);
01977 #           endif
01978             iopc_inv = (float)1. - iopc;
01979             ;
01980             iopc += acc_opc * iopc_inv;
01981             ipixel->opcflt = iopc;
01982             
01983 #ifdef DEBUG
01984     if (ipixel == trace_pixel_ptr) {
01985 #ifdef COMPUTE_SHADOW_BUFFER
01986         printf("{%3d}  %3d %3d", k, icount-i-count, j);
01987 #else
01988         printf("[%3d]  %3d %3d", k, icount-i-count, j);
01989 #endif
01990         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01991         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01992         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01993         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01994         printf("  %3.0f %3.0f\n", iopc*255., 
01995                0);
01996         
01997         
01998     }
01999 #endif /* DEBUG */
02000 ;
02001 #           ifndef SKIP_ERT
02002                 if (iopc >= max_opacity) {
02003                     ASSERT(ipixel->lnk == 0);
02004                     ipixel->lnk = 1;
02005                 }
02006 #           endif
02007         };
02008                 ipixel += 1;
02009                 topRLEdata += 1 * voxel_istride;
02010                 botRLEdata += 1 * voxel_istride;
02011                 count--;
02012                 SET_VOXELS_LOADED;
02013 
02014                 /* do the rest of the pixels in this run;
02015                    the top-left and top-right voxels contribute */
02016                 while (count > 0) {
02017                     if (PIXEL_IS_OPAQUE(ipixel))
02018                         break;
02019                     if (!voxels_loaded) {
02020                         
02021     
02022             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02023             opacity = param0_table[opac_param];
02024             if (param1_size != 0) {
02025                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02026                 opacity *= param1_table[opac_param];
02027                 if (param2_size != 0) {
02028                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02029                     opacity *= param2_table[opac_param];
02030                 }
02031             }
02032             if (opacity > min_opacity) {
02033                 opacity_int = opacity*255.;
02034                 top_opc = opac_correct[opacity_int];
02035             } else {
02036                 top_opc = (float)0.;
02037             };
02038     
02039     ;
02040                     }
02041                     
02042 #ifdef DEBUG
02043     if (ipixel == trace_pixel_ptr) {
02044         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02045         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02046         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02047         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02048         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02049     }
02050 #endif
02051 ;
02052                     
02053        acc_opc = top_opc * wgtTL;
02054        ;
02055        
02056 #ifdef DEBUG
02057     if (ipixel == trace_pixel_ptr) {
02058         trace_opcTL = top_opc;
02059         
02060         
02061     }
02062 #endif
02063 ;
02064                     
02065     
02066             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
02067             opacity = param0_table[opac_param];
02068             if (param1_size != 0) {
02069                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
02070                 opacity *= param1_table[opac_param];
02071                 if (param2_size != 0) {
02072                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
02073                     opacity *= param2_table[opac_param];
02074                 }
02075             }
02076             if (opacity > min_opacity) {
02077                 opacity_int = opacity*255.;
02078                 top_opc = opac_correct[opacity_int];
02079             } else {
02080                 top_opc = (float)0.;
02081             };
02082     
02083     ;
02084                     
02085        acc_opc += top_opc * wgtTR;
02086        ;
02087        
02088 #ifdef DEBUG
02089     if (ipixel == trace_pixel_ptr) {
02090         trace_opcTR = top_opc;
02091         
02092         
02093     }
02094 #endif
02095 ;
02096                     
02097         COUNT_RESAMPLE;
02098         if (acc_opc > min_opacity) {
02099             COUNT_COMPOSITE;
02100             iopc = ipixel->opcflt;
02101 #           ifndef SKIP_ERT
02102                 ASSERT(iopc < max_opacity);
02103 #           endif
02104             iopc_inv = (float)1. - iopc;
02105             ;
02106             iopc += acc_opc * iopc_inv;
02107             ipixel->opcflt = iopc;
02108             
02109 #ifdef DEBUG
02110     if (ipixel == trace_pixel_ptr) {
02111 #ifdef COMPUTE_SHADOW_BUFFER
02112         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02113 #else
02114         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02115 #endif
02116         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02117         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02118         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02119         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02120         printf("  %3.0f %3.0f\n", iopc*255., 
02121                0);
02122         
02123         
02124     }
02125 #endif /* DEBUG */
02126 ;
02127 #           ifndef SKIP_ERT
02128                 if (iopc >= max_opacity) {
02129                     ASSERT(ipixel->lnk == 0);
02130                     ipixel->lnk = 1;
02131                 }
02132 #           endif
02133         };
02134                     ipixel += 1;
02135                     topRLEdata += 1 * voxel_istride;
02136                     botRLEdata += 1 * voxel_istride;
02137                     count--;
02138                     SET_VOXELS_LOADED;
02139                 }
02140                 break;
02141             case ALL_ZERO__BOT_NONZERO:
02142                 /* first pixel: only the bottom-right voxel contributes */
02143                 
02144     
02145             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02146             opacity = param0_table[opac_param];
02147             if (param1_size != 0) {
02148                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02149                 opacity *= param1_table[opac_param];
02150                 if (param2_size != 0) {
02151                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02152                     opacity *= param2_table[opac_param];
02153                 }
02154             }
02155             if (opacity > min_opacity) {
02156                 opacity_int = opacity*255.;
02157                 bot_opc = opac_correct[opacity_int];
02158             } else {
02159                 bot_opc = (float)0.;
02160             };
02161     
02162     ;
02163                 
02164 #ifdef DEBUG
02165     if (ipixel == trace_pixel_ptr) {
02166         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02167         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02168         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02169         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02170         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02171     }
02172 #endif
02173 ;
02174                 
02175        acc_opc = bot_opc * wgtBR;
02176        ;
02177        
02178 #ifdef DEBUG
02179     if (ipixel == trace_pixel_ptr) {
02180         trace_opcBR = bot_opc;
02181         
02182         
02183     }
02184 #endif
02185 ;
02186                 
02187         COUNT_RESAMPLE;
02188         if (acc_opc > min_opacity) {
02189             COUNT_COMPOSITE;
02190             iopc = ipixel->opcflt;
02191 #           ifndef SKIP_ERT
02192                 ASSERT(iopc < max_opacity);
02193 #           endif
02194             iopc_inv = (float)1. - iopc;
02195             ;
02196             iopc += acc_opc * iopc_inv;
02197             ipixel->opcflt = iopc;
02198             
02199 #ifdef DEBUG
02200     if (ipixel == trace_pixel_ptr) {
02201 #ifdef COMPUTE_SHADOW_BUFFER
02202         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02203 #else
02204         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02205 #endif
02206         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02207         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02208         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02209         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02210         printf("  %3.0f %3.0f\n", iopc*255., 
02211                0);
02212         
02213         
02214     }
02215 #endif /* DEBUG */
02216 ;
02217 #           ifndef SKIP_ERT
02218                 if (iopc >= max_opacity) {
02219                     ASSERT(ipixel->lnk == 0);
02220                     ipixel->lnk = 1;
02221                 }
02222 #           endif
02223         };      
02224                 ipixel += 1;
02225                 topRLEdata += 1 * voxel_istride;
02226                 botRLEdata += 1 * voxel_istride;
02227                 count--;
02228                 SET_VOXELS_LOADED;
02229 
02230                 /* do the rest of the pixels in this run;
02231                    bottom-left and bottom-right voxels contribute */
02232                 while (count > 0) {
02233                     if (PIXEL_IS_OPAQUE(ipixel))
02234                         break;
02235                     if (!voxels_loaded) {
02236                         
02237     
02238             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02239             opacity = param0_table[opac_param];
02240             if (param1_size != 0) {
02241                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02242                 opacity *= param1_table[opac_param];
02243                 if (param2_size != 0) {
02244                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02245                     opacity *= param2_table[opac_param];
02246                 }
02247             }
02248             if (opacity > min_opacity) {
02249                 opacity_int = opacity*255.;
02250                 bot_opc = opac_correct[opacity_int];
02251             } else {
02252                 bot_opc = (float)0.;
02253             };
02254     
02255     ;
02256                     }
02257                     
02258 #ifdef DEBUG
02259     if (ipixel == trace_pixel_ptr) {
02260         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02261         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02262         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02263         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02264         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02265     }
02266 #endif
02267 ;
02268                     
02269        acc_opc = bot_opc * wgtBL;
02270        ;
02271        
02272 #ifdef DEBUG
02273     if (ipixel == trace_pixel_ptr) {
02274         trace_opcBL = bot_opc;
02275         
02276         
02277     }
02278 #endif
02279 ;
02280                     
02281     
02282             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02283             opacity = param0_table[opac_param];
02284             if (param1_size != 0) {
02285                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02286                 opacity *= param1_table[opac_param];
02287                 if (param2_size != 0) {
02288                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02289                     opacity *= param2_table[opac_param];
02290                 }
02291             }
02292             if (opacity > min_opacity) {
02293                 opacity_int = opacity*255.;
02294                 bot_opc = opac_correct[opacity_int];
02295             } else {
02296                 bot_opc = (float)0.;
02297             };
02298     
02299     ;
02300                     
02301        acc_opc += bot_opc * wgtBR;
02302        ;
02303        
02304 #ifdef DEBUG
02305     if (ipixel == trace_pixel_ptr) {
02306         trace_opcBR = bot_opc;
02307         
02308         
02309     }
02310 #endif
02311 ;
02312                     
02313         COUNT_RESAMPLE;
02314         if (acc_opc > min_opacity) {
02315             COUNT_COMPOSITE;
02316             iopc = ipixel->opcflt;
02317 #           ifndef SKIP_ERT
02318                 ASSERT(iopc < max_opacity);
02319 #           endif
02320             iopc_inv = (float)1. - iopc;
02321             ;
02322             iopc += acc_opc * iopc_inv;
02323             ipixel->opcflt = iopc;
02324             
02325 #ifdef DEBUG
02326     if (ipixel == trace_pixel_ptr) {
02327 #ifdef COMPUTE_SHADOW_BUFFER
02328         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02329 #else
02330         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02331 #endif
02332         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02333         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02334         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02335         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02336         printf("  %3.0f %3.0f\n", iopc*255., 
02337                0);
02338         
02339         
02340     }
02341 #endif /* DEBUG */
02342 ;
02343 #           ifndef SKIP_ERT
02344                 if (iopc >= max_opacity) {
02345                     ASSERT(ipixel->lnk == 0);
02346                     ipixel->lnk = 1;
02347                 }
02348 #           endif
02349         };
02350                     ipixel += 1;
02351                     topRLEdata += 1 * voxel_istride;
02352                     botRLEdata += 1 * voxel_istride;
02353                     count--;
02354                     SET_VOXELS_LOADED;
02355                 }
02356                 break;
02357             case TOP_NONZERO__BOT_NONZERO:
02358                 /* first pixel: top-left and bottom-right voxels contribute */
02359                 if (!voxels_loaded) {
02360                     
02361     
02362             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02363             opacity = param0_table[opac_param];
02364             if (param1_size != 0) {
02365                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02366                 opacity *= param1_table[opac_param];
02367                 if (param2_size != 0) {
02368                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02369                     opacity *= param2_table[opac_param];
02370                 }
02371             }
02372             if (opacity > min_opacity) {
02373                 opacity_int = opacity*255.;
02374                 top_opc = opac_correct[opacity_int];
02375             } else {
02376                 top_opc = (float)0.;
02377             };
02378     
02379     ;
02380                 }
02381                 
02382 #ifdef DEBUG
02383     if (ipixel == trace_pixel_ptr) {
02384         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02385         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02386         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02387         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02388         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02389     }
02390 #endif
02391 ;
02392                 
02393        acc_opc = top_opc * wgtTL;
02394        ;
02395        
02396 #ifdef DEBUG
02397     if (ipixel == trace_pixel_ptr) {
02398         trace_opcTL = top_opc;
02399         
02400         
02401     }
02402 #endif
02403 ;
02404                 
02405     
02406             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02407             opacity = param0_table[opac_param];
02408             if (param1_size != 0) {
02409                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02410                 opacity *= param1_table[opac_param];
02411                 if (param2_size != 0) {
02412                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02413                     opacity *= param2_table[opac_param];
02414                 }
02415             }
02416             if (opacity > min_opacity) {
02417                 opacity_int = opacity*255.;
02418                 bot_opc = opac_correct[opacity_int];
02419             } else {
02420                 bot_opc = (float)0.;
02421             };
02422     
02423     ;
02424                 
02425        acc_opc += bot_opc * wgtBR;
02426        ;
02427        
02428 #ifdef DEBUG
02429     if (ipixel == trace_pixel_ptr) {
02430         trace_opcBR = bot_opc;
02431         
02432         
02433     }
02434 #endif
02435 ;
02436                 
02437         COUNT_RESAMPLE;
02438         if (acc_opc > min_opacity) {
02439             COUNT_COMPOSITE;
02440             iopc = ipixel->opcflt;
02441 #           ifndef SKIP_ERT
02442                 ASSERT(iopc < max_opacity);
02443 #           endif
02444             iopc_inv = (float)1. - iopc;
02445             ;
02446             iopc += acc_opc * iopc_inv;
02447             ipixel->opcflt = iopc;
02448             
02449 #ifdef DEBUG
02450     if (ipixel == trace_pixel_ptr) {
02451 #ifdef COMPUTE_SHADOW_BUFFER
02452         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02453 #else
02454         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02455 #endif
02456         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02457         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02458         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02459         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02460         printf("  %3.0f %3.0f\n", iopc*255., 
02461                0);
02462         
02463         
02464     }
02465 #endif /* DEBUG */
02466 ;
02467 #           ifndef SKIP_ERT
02468                 if (iopc >= max_opacity) {
02469                     ASSERT(ipixel->lnk == 0);
02470                     ipixel->lnk = 1;
02471                 }
02472 #           endif
02473         };
02474                 ipixel += 1;
02475                 topRLEdata += 1 * voxel_istride;
02476                 botRLEdata += 1 * voxel_istride;
02477                 count--;
02478                 SET_VOXELS_LOADED;
02479 
02480                 /* do the rest of the pixels in this run;
02481                    bottom-left and bottom-right voxels contribute */
02482                 while (count > 0) {
02483                     if (PIXEL_IS_OPAQUE(ipixel))
02484                         break;
02485                     if (!voxels_loaded) {
02486                         
02487     
02488             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02489             opacity = param0_table[opac_param];
02490             if (param1_size != 0) {
02491                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02492                 opacity *= param1_table[opac_param];
02493                 if (param2_size != 0) {
02494                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02495                     opacity *= param2_table[opac_param];
02496                 }
02497             }
02498             if (opacity > min_opacity) {
02499                 opacity_int = opacity*255.;
02500                 bot_opc = opac_correct[opacity_int];
02501             } else {
02502                 bot_opc = (float)0.;
02503             };
02504     
02505     ;
02506                     }
02507                     
02508 #ifdef DEBUG
02509     if (ipixel == trace_pixel_ptr) {
02510         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02511         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02512         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02513         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02514         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02515     }
02516 #endif
02517 ;
02518                     
02519        acc_opc = bot_opc * wgtBL;
02520        ;
02521        
02522 #ifdef DEBUG
02523     if (ipixel == trace_pixel_ptr) {
02524         trace_opcBL = bot_opc;
02525         
02526         
02527     }
02528 #endif
02529 ;
02530                     
02531     
02532             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02533             opacity = param0_table[opac_param];
02534             if (param1_size != 0) {
02535                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02536                 opacity *= param1_table[opac_param];
02537                 if (param2_size != 0) {
02538                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02539                     opacity *= param2_table[opac_param];
02540                 }
02541             }
02542             if (opacity > min_opacity) {
02543                 opacity_int = opacity*255.;
02544                 bot_opc = opac_correct[opacity_int];
02545             } else {
02546                 bot_opc = (float)0.;
02547             };
02548     
02549     ;
02550                     
02551        acc_opc += bot_opc * wgtBR;
02552        ;
02553        
02554 #ifdef DEBUG
02555     if (ipixel == trace_pixel_ptr) {
02556         trace_opcBR = bot_opc;
02557         
02558         
02559     }
02560 #endif
02561 ;
02562                     
02563         COUNT_RESAMPLE;
02564         if (acc_opc > min_opacity) {
02565             COUNT_COMPOSITE;
02566             iopc = ipixel->opcflt;
02567 #           ifndef SKIP_ERT
02568                 ASSERT(iopc < max_opacity);
02569 #           endif
02570             iopc_inv = (float)1. - iopc;
02571             ;
02572             iopc += acc_opc * iopc_inv;
02573             ipixel->opcflt = iopc;
02574             
02575 #ifdef DEBUG
02576     if (ipixel == trace_pixel_ptr) {
02577 #ifdef COMPUTE_SHADOW_BUFFER
02578         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02579 #else
02580         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02581 #endif
02582         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02583         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02584         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02585         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02586         printf("  %3.0f %3.0f\n", iopc*255., 
02587                0);
02588         
02589         
02590     }
02591 #endif /* DEBUG */
02592 ;
02593 #           ifndef SKIP_ERT
02594                 if (iopc >= max_opacity) {
02595                     ASSERT(ipixel->lnk == 0);
02596                     ipixel->lnk = 1;
02597                 }
02598 #           endif
02599         };
02600                     ipixel += 1;
02601                     topRLEdata += 1 * voxel_istride;
02602                     botRLEdata += 1 * voxel_istride;
02603                     count--;
02604                     SET_VOXELS_LOADED;
02605                 }
02606                 break;
02607             case BOT_NONZERO__BOT_NONZERO:
02608                 /* do the pixels in this run; bottom-left and
02609                    bottom-right voxels contribute */
02610                 while (count > 0) {
02611                     if (PIXEL_IS_OPAQUE(ipixel))
02612                         break;
02613                     if (!voxels_loaded) {
02614                         
02615     
02616             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02617             opacity = param0_table[opac_param];
02618             if (param1_size != 0) {
02619                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02620                 opacity *= param1_table[opac_param];
02621                 if (param2_size != 0) {
02622                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02623                     opacity *= param2_table[opac_param];
02624                 }
02625             }
02626             if (opacity > min_opacity) {
02627                 opacity_int = opacity*255.;
02628                 bot_opc = opac_correct[opacity_int];
02629             } else {
02630                 bot_opc = (float)0.;
02631             };
02632     
02633     ;
02634                     }
02635                     
02636 #ifdef DEBUG
02637     if (ipixel == trace_pixel_ptr) {
02638         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02639         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02640         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02641         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02642         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02643     }
02644 #endif
02645 ;
02646                     
02647        acc_opc = bot_opc * wgtBL;
02648        ;
02649        
02650 #ifdef DEBUG
02651     if (ipixel == trace_pixel_ptr) {
02652         trace_opcBL = bot_opc;
02653         
02654         
02655     }
02656 #endif
02657 ;
02658                     
02659     
02660             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02661             opacity = param0_table[opac_param];
02662             if (param1_size != 0) {
02663                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02664                 opacity *= param1_table[opac_param];
02665                 if (param2_size != 0) {
02666                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02667                     opacity *= param2_table[opac_param];
02668                 }
02669             }
02670             if (opacity > min_opacity) {
02671                 opacity_int = opacity*255.;
02672                 bot_opc = opac_correct[opacity_int];
02673             } else {
02674                 bot_opc = (float)0.;
02675             };
02676     
02677     ;
02678                     
02679        acc_opc += bot_opc * wgtBR;
02680        ;
02681        
02682 #ifdef DEBUG
02683     if (ipixel == trace_pixel_ptr) {
02684         trace_opcBR = bot_opc;
02685         
02686         
02687     }
02688 #endif
02689 ;
02690                     
02691         COUNT_RESAMPLE;
02692         if (acc_opc > min_opacity) {
02693             COUNT_COMPOSITE;
02694             iopc = ipixel->opcflt;
02695 #           ifndef SKIP_ERT
02696                 ASSERT(iopc < max_opacity);
02697 #           endif
02698             iopc_inv = (float)1. - iopc;
02699             ;
02700             iopc += acc_opc * iopc_inv;
02701             ipixel->opcflt = iopc;
02702             
02703 #ifdef DEBUG
02704     if (ipixel == trace_pixel_ptr) {
02705 #ifdef COMPUTE_SHADOW_BUFFER
02706         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02707 #else
02708         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02709 #endif
02710         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02711         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02712         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02713         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02714         printf("  %3.0f %3.0f\n", iopc*255., 
02715                0);
02716         
02717         
02718     }
02719 #endif /* DEBUG */
02720 ;
02721 #           ifndef SKIP_ERT
02722                 if (iopc >= max_opacity) {
02723                     ASSERT(ipixel->lnk == 0);
02724                     ipixel->lnk = 1;
02725                 }
02726 #           endif
02727         };
02728                     ipixel += 1;
02729                     topRLEdata += 1 * voxel_istride;
02730                     botRLEdata += 1 * voxel_istride;
02731                     count--;
02732                     SET_VOXELS_LOADED;
02733                 }
02734                 break;
02735             case ALL_NONZERO__BOT_NONZERO:
02736                 /* first pixel: top-left, bottom-left and bottom-right
02737                    voxels contribute */
02738                 if (!voxels_loaded) {
02739                     
02740     
02741             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02742             opacity = param0_table[opac_param];
02743             if (param1_size != 0) {
02744                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02745                 opacity *= param1_table[opac_param];
02746                 if (param2_size != 0) {
02747                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02748                     opacity *= param2_table[opac_param];
02749                 }
02750             }
02751             if (opacity > min_opacity) {
02752                 opacity_int = opacity*255.;
02753                 top_opc = opac_correct[opacity_int];
02754             } else {
02755                 top_opc = (float)0.;
02756             };
02757     
02758     ;
02759                     
02760     
02761             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02762             opacity = param0_table[opac_param];
02763             if (param1_size != 0) {
02764                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02765                 opacity *= param1_table[opac_param];
02766                 if (param2_size != 0) {
02767                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02768                     opacity *= param2_table[opac_param];
02769                 }
02770             }
02771             if (opacity > min_opacity) {
02772                 opacity_int = opacity*255.;
02773                 bot_opc = opac_correct[opacity_int];
02774             } else {
02775                 bot_opc = (float)0.;
02776             };
02777     
02778     ;
02779                 }
02780                 
02781 #ifdef DEBUG
02782     if (ipixel == trace_pixel_ptr) {
02783         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02784         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02785         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02786         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02787         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02788     }
02789 #endif
02790 ;
02791                 
02792        acc_opc = top_opc * wgtTL;
02793        ;
02794        
02795 #ifdef DEBUG
02796     if (ipixel == trace_pixel_ptr) {
02797         trace_opcTL = top_opc;
02798         
02799         
02800     }
02801 #endif
02802 ;
02803                 
02804        acc_opc += bot_opc * wgtBL;
02805        ;
02806        
02807 #ifdef DEBUG
02808     if (ipixel == trace_pixel_ptr) {
02809         trace_opcBL = bot_opc;
02810         
02811         
02812     }
02813 #endif
02814 ;
02815                 
02816     
02817             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02818             opacity = param0_table[opac_param];
02819             if (param1_size != 0) {
02820                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02821                 opacity *= param1_table[opac_param];
02822                 if (param2_size != 0) {
02823                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02824                     opacity *= param2_table[opac_param];
02825                 }
02826             }
02827             if (opacity > min_opacity) {
02828                 opacity_int = opacity*255.;
02829                 bot_opc = opac_correct[opacity_int];
02830             } else {
02831                 bot_opc = (float)0.;
02832             };
02833     
02834     ;
02835                 
02836        acc_opc += bot_opc * wgtBR;
02837        ;
02838        
02839 #ifdef DEBUG
02840     if (ipixel == trace_pixel_ptr) {
02841         trace_opcBR = bot_opc;
02842         
02843         
02844     }
02845 #endif
02846 ;
02847                 
02848         COUNT_RESAMPLE;
02849         if (acc_opc > min_opacity) {
02850             COUNT_COMPOSITE;
02851             iopc = ipixel->opcflt;
02852 #           ifndef SKIP_ERT
02853                 ASSERT(iopc < max_opacity);
02854 #           endif
02855             iopc_inv = (float)1. - iopc;
02856             ;
02857             iopc += acc_opc * iopc_inv;
02858             ipixel->opcflt = iopc;
02859             
02860 #ifdef DEBUG
02861     if (ipixel == trace_pixel_ptr) {
02862 #ifdef COMPUTE_SHADOW_BUFFER
02863         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02864 #else
02865         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02866 #endif
02867         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02868         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02869         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02870         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02871         printf("  %3.0f %3.0f\n", iopc*255., 
02872                0);
02873         
02874         
02875     }
02876 #endif /* DEBUG */
02877 ;
02878 #           ifndef SKIP_ERT
02879                 if (iopc >= max_opacity) {
02880                     ASSERT(ipixel->lnk == 0);
02881                     ipixel->lnk = 1;
02882                 }
02883 #           endif
02884         };
02885                 ipixel += 1;
02886                 topRLEdata += 1 * voxel_istride;
02887                 botRLEdata += 1 * voxel_istride;
02888                 count--;
02889                 SET_VOXELS_LOADED;
02890 
02891                 /* do the rest of the pixels in this run;
02892                    bottom-left and bottom-right voxels contribute */
02893                 while (count > 0) {
02894                     if (PIXEL_IS_OPAQUE(ipixel))
02895                         break;
02896                     if (!voxels_loaded) {
02897                         
02898     
02899             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02900             opacity = param0_table[opac_param];
02901             if (param1_size != 0) {
02902                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02903                 opacity *= param1_table[opac_param];
02904                 if (param2_size != 0) {
02905                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02906                     opacity *= param2_table[opac_param];
02907                 }
02908             }
02909             if (opacity > min_opacity) {
02910                 opacity_int = opacity*255.;
02911                 bot_opc = opac_correct[opacity_int];
02912             } else {
02913                 bot_opc = (float)0.;
02914             };
02915     
02916     ;
02917                     }
02918                     
02919 #ifdef DEBUG
02920     if (ipixel == trace_pixel_ptr) {
02921         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02922         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02923         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02924         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02925         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02926     }
02927 #endif
02928 ;
02929                     
02930        acc_opc = bot_opc * wgtBL;
02931        ;
02932        
02933 #ifdef DEBUG
02934     if (ipixel == trace_pixel_ptr) {
02935         trace_opcBL = bot_opc;
02936         
02937         
02938     }
02939 #endif
02940 ;
02941                     
02942     
02943             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02944             opacity = param0_table[opac_param];
02945             if (param1_size != 0) {
02946                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02947                 opacity *= param1_table[opac_param];
02948                 if (param2_size != 0) {
02949                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02950                     opacity *= param2_table[opac_param];
02951                 }
02952             }
02953             if (opacity > min_opacity) {
02954                 opacity_int = opacity*255.;
02955                 bot_opc = opac_correct[opacity_int];
02956             } else {
02957                 bot_opc = (float)0.;
02958             };
02959     
02960     ;
02961                     
02962        acc_opc += bot_opc * wgtBR;
02963        ;
02964        
02965 #ifdef DEBUG
02966     if (ipixel == trace_pixel_ptr) {
02967         trace_opcBR = bot_opc;
02968         
02969         
02970     }
02971 #endif
02972 ;
02973                     
02974         COUNT_RESAMPLE;
02975         if (acc_opc > min_opacity) {
02976             COUNT_COMPOSITE;
02977             iopc = ipixel->opcflt;
02978 #           ifndef SKIP_ERT
02979                 ASSERT(iopc < max_opacity);
02980 #           endif
02981             iopc_inv = (float)1. - iopc;
02982             ;
02983             iopc += acc_opc * iopc_inv;
02984             ipixel->opcflt = iopc;
02985             
02986 #ifdef DEBUG
02987     if (ipixel == trace_pixel_ptr) {
02988 #ifdef COMPUTE_SHADOW_BUFFER
02989         printf("{%3d}  %3d %3d", k, icount-i-count, j);
02990 #else
02991         printf("[%3d]  %3d %3d", k, icount-i-count, j);
02992 #endif
02993         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02994         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02995         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02996         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02997         printf("  %3.0f %3.0f\n", iopc*255., 
02998                0);
02999         
03000         
03001     }
03002 #endif /* DEBUG */
03003 ;
03004 #           ifndef SKIP_ERT
03005                 if (iopc >= max_opacity) {
03006                     ASSERT(ipixel->lnk == 0);
03007                     ipixel->lnk = 1;
03008                 }
03009 #           endif
03010         };
03011                     ipixel += 1;
03012                     topRLEdata += 1 * voxel_istride;
03013                     botRLEdata += 1 * voxel_istride;
03014                     count--;
03015                     SET_VOXELS_LOADED;
03016                 }
03017                 break;
03018             case ALL_ZERO__ALL_NONZERO:
03019                 /* first pixel: top-right and bottom-right voxels contribute */
03020                 
03021     
03022             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03023             opacity = param0_table[opac_param];
03024             if (param1_size != 0) {
03025                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03026                 opacity *= param1_table[opac_param];
03027                 if (param2_size != 0) {
03028                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03029                     opacity *= param2_table[opac_param];
03030                 }
03031             }
03032             if (opacity > min_opacity) {
03033                 opacity_int = opacity*255.;
03034                 top_opc = opac_correct[opacity_int];
03035             } else {
03036                 top_opc = (float)0.;
03037             };
03038     
03039     ;
03040                 
03041     
03042             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03043             opacity = param0_table[opac_param];
03044             if (param1_size != 0) {
03045                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03046                 opacity *= param1_table[opac_param];
03047                 if (param2_size != 0) {
03048                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03049                     opacity *= param2_table[opac_param];
03050                 }
03051             }
03052             if (opacity > min_opacity) {
03053                 opacity_int = opacity*255.;
03054                 bot_opc = opac_correct[opacity_int];
03055             } else {
03056                 bot_opc = (float)0.;
03057             };
03058     
03059     ;
03060                 
03061 #ifdef DEBUG
03062     if (ipixel == trace_pixel_ptr) {
03063         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03064         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03065         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03066         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03067         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03068     }
03069 #endif
03070 ;
03071                 
03072        acc_opc = top_opc * wgtTR;
03073        ;
03074        
03075 #ifdef DEBUG
03076     if (ipixel == trace_pixel_ptr) {
03077         trace_opcTR = top_opc;
03078         
03079         
03080     }
03081 #endif
03082 ;
03083                 
03084        acc_opc += bot_opc * wgtBR;
03085        ;
03086        
03087 #ifdef DEBUG
03088     if (ipixel == trace_pixel_ptr) {
03089         trace_opcBR = bot_opc;
03090         
03091         
03092     }
03093 #endif
03094 ;
03095                 
03096         COUNT_RESAMPLE;
03097         if (acc_opc > min_opacity) {
03098             COUNT_COMPOSITE;
03099             iopc = ipixel->opcflt;
03100 #           ifndef SKIP_ERT
03101                 ASSERT(iopc < max_opacity);
03102 #           endif
03103             iopc_inv = (float)1. - iopc;
03104             ;
03105             iopc += acc_opc * iopc_inv;
03106             ipixel->opcflt = iopc;
03107             
03108 #ifdef DEBUG
03109     if (ipixel == trace_pixel_ptr) {
03110 #ifdef COMPUTE_SHADOW_BUFFER
03111         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03112 #else
03113         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03114 #endif
03115         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03116         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03117         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03118         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03119         printf("  %3.0f %3.0f\n", iopc*255., 
03120                0);
03121         
03122         
03123     }
03124 #endif /* DEBUG */
03125 ;
03126 #           ifndef SKIP_ERT
03127                 if (iopc >= max_opacity) {
03128                     ASSERT(ipixel->lnk == 0);
03129                     ipixel->lnk = 1;
03130                 }
03131 #           endif
03132         };
03133                 ipixel += 1;
03134                 topRLEdata += 1 * voxel_istride;
03135                 botRLEdata += 1 * voxel_istride;
03136                 count--;
03137                 SET_VOXELS_LOADED;
03138 
03139                 /* do the rest of the pixels in this run;
03140                    all four voxels contribute */
03141                 while (count > 0) {
03142                     if (PIXEL_IS_OPAQUE(ipixel))
03143                         break;
03144                     if (!voxels_loaded) {
03145                         
03146     
03147             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03148             opacity = param0_table[opac_param];
03149             if (param1_size != 0) {
03150                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03151                 opacity *= param1_table[opac_param];
03152                 if (param2_size != 0) {
03153                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03154                     opacity *= param2_table[opac_param];
03155                 }
03156             }
03157             if (opacity > min_opacity) {
03158                 opacity_int = opacity*255.;
03159                 top_opc = opac_correct[opacity_int];
03160             } else {
03161                 top_opc = (float)0.;
03162             };
03163     
03164     ;
03165                         
03166     
03167             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03168             opacity = param0_table[opac_param];
03169             if (param1_size != 0) {
03170                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03171                 opacity *= param1_table[opac_param];
03172                 if (param2_size != 0) {
03173                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03174                     opacity *= param2_table[opac_param];
03175                 }
03176             }
03177             if (opacity > min_opacity) {
03178                 opacity_int = opacity*255.;
03179                 bot_opc = opac_correct[opacity_int];
03180             } else {
03181                 bot_opc = (float)0.;
03182             };
03183     
03184     ;
03185                     }
03186                     
03187 #ifdef DEBUG
03188     if (ipixel == trace_pixel_ptr) {
03189         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03190         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03191         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03192         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03193         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03194     }
03195 #endif
03196 ;
03197                     
03198        acc_opc = top_opc * wgtTL;
03199        ;
03200        
03201 #ifdef DEBUG
03202     if (ipixel == trace_pixel_ptr) {
03203         trace_opcTL = top_opc;
03204         
03205         
03206     }
03207 #endif
03208 ;
03209                     
03210        acc_opc += bot_opc * wgtBL;
03211        ;
03212        
03213 #ifdef DEBUG
03214     if (ipixel == trace_pixel_ptr) {
03215         trace_opcBL = bot_opc;
03216         
03217         
03218     }
03219 #endif
03220 ;
03221                     
03222     
03223             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03224             opacity = param0_table[opac_param];
03225             if (param1_size != 0) {
03226                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03227                 opacity *= param1_table[opac_param];
03228                 if (param2_size != 0) {
03229                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03230                     opacity *= param2_table[opac_param];
03231                 }
03232             }
03233             if (opacity > min_opacity) {
03234                 opacity_int = opacity*255.;
03235                 top_opc = opac_correct[opacity_int];
03236             } else {
03237                 top_opc = (float)0.;
03238             };
03239     
03240     ;
03241                     
03242     
03243             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03244             opacity = param0_table[opac_param];
03245             if (param1_size != 0) {
03246                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03247                 opacity *= param1_table[opac_param];
03248                 if (param2_size != 0) {
03249                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03250                     opacity *= param2_table[opac_param];
03251                 }
03252             }
03253             if (opacity > min_opacity) {
03254                 opacity_int = opacity*255.;
03255                 bot_opc = opac_correct[opacity_int];
03256             } else {
03257                 bot_opc = (float)0.;
03258             };
03259     
03260     ;
03261                     
03262        acc_opc += top_opc * wgtTR;
03263        ;
03264        
03265 #ifdef DEBUG
03266     if (ipixel == trace_pixel_ptr) {
03267         trace_opcTR = top_opc;
03268         
03269         
03270     }
03271 #endif
03272 ;
03273                     
03274        acc_opc += bot_opc * wgtBR;
03275        ;
03276        
03277 #ifdef DEBUG
03278     if (ipixel == trace_pixel_ptr) {
03279         trace_opcBR = bot_opc;
03280         
03281         
03282     }
03283 #endif
03284 ;
03285                     
03286         COUNT_RESAMPLE;
03287         if (acc_opc > min_opacity) {
03288             COUNT_COMPOSITE;
03289             iopc = ipixel->opcflt;
03290 #           ifndef SKIP_ERT
03291                 ASSERT(iopc < max_opacity);
03292 #           endif
03293             iopc_inv = (float)1. - iopc;
03294             ;
03295             iopc += acc_opc * iopc_inv;
03296             ipixel->opcflt = iopc;
03297             
03298 #ifdef DEBUG
03299     if (ipixel == trace_pixel_ptr) {
03300 #ifdef COMPUTE_SHADOW_BUFFER
03301         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03302 #else
03303         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03304 #endif
03305         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03306         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03307         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03308         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03309         printf("  %3.0f %3.0f\n", iopc*255., 
03310                0);
03311         
03312         
03313     }
03314 #endif /* DEBUG */
03315 ;
03316 #           ifndef SKIP_ERT
03317                 if (iopc >= max_opacity) {
03318                     ASSERT(ipixel->lnk == 0);
03319                     ipixel->lnk = 1;
03320                 }
03321 #           endif
03322         };
03323                     ipixel += 1;
03324                     topRLEdata += 1 * voxel_istride;
03325                     botRLEdata += 1 * voxel_istride;
03326                     count--;
03327                     SET_VOXELS_LOADED;
03328                 }
03329                 break;
03330             case TOP_NONZERO__ALL_NONZERO:
03331                 /* first pixel: top-left, top-right and bottom-right
03332                    voxels contribute */
03333                 if (!voxels_loaded) {
03334                     
03335     
03336             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03337             opacity = param0_table[opac_param];
03338             if (param1_size != 0) {
03339                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03340                 opacity *= param1_table[opac_param];
03341                 if (param2_size != 0) {
03342                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03343                     opacity *= param2_table[opac_param];
03344                 }
03345             }
03346             if (opacity > min_opacity) {
03347                 opacity_int = opacity*255.;
03348                 top_opc = opac_correct[opacity_int];
03349             } else {
03350                 top_opc = (float)0.;
03351             };
03352     
03353     ;
03354                 }
03355                 
03356 #ifdef DEBUG
03357     if (ipixel == trace_pixel_ptr) {
03358         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03359         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03360         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03361         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03362         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03363     }
03364 #endif
03365 ;
03366                 
03367        acc_opc = top_opc * wgtTL;
03368        ;
03369        
03370 #ifdef DEBUG
03371     if (ipixel == trace_pixel_ptr) {
03372         trace_opcTL = top_opc;
03373         
03374         
03375     }
03376 #endif
03377 ;
03378                 
03379     
03380             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03381             opacity = param0_table[opac_param];
03382             if (param1_size != 0) {
03383                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03384                 opacity *= param1_table[opac_param];
03385                 if (param2_size != 0) {
03386                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03387                     opacity *= param2_table[opac_param];
03388                 }
03389             }
03390             if (opacity > min_opacity) {
03391                 opacity_int = opacity*255.;
03392                 top_opc = opac_correct[opacity_int];
03393             } else {
03394                 top_opc = (float)0.;
03395             };
03396     
03397     ;
03398                 
03399     
03400             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03401             opacity = param0_table[opac_param];
03402             if (param1_size != 0) {
03403                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03404                 opacity *= param1_table[opac_param];
03405                 if (param2_size != 0) {
03406                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03407                     opacity *= param2_table[opac_param];
03408                 }
03409             }
03410             if (opacity > min_opacity) {
03411                 opacity_int = opacity*255.;
03412                 bot_opc = opac_correct[opacity_int];
03413             } else {
03414                 bot_opc = (float)0.;
03415             };
03416     
03417     ;
03418                 
03419        acc_opc += top_opc * wgtTR;
03420        ;
03421        
03422 #ifdef DEBUG
03423     if (ipixel == trace_pixel_ptr) {
03424         trace_opcTR = top_opc;
03425         
03426         
03427     }
03428 #endif
03429 ;
03430                 
03431        acc_opc += bot_opc * wgtBR;
03432        ;
03433        
03434 #ifdef DEBUG
03435     if (ipixel == trace_pixel_ptr) {
03436         trace_opcBR = bot_opc;
03437         
03438         
03439     }
03440 #endif
03441 ;
03442                 
03443         COUNT_RESAMPLE;
03444         if (acc_opc > min_opacity) {
03445             COUNT_COMPOSITE;
03446             iopc = ipixel->opcflt;
03447 #           ifndef SKIP_ERT
03448                 ASSERT(iopc < max_opacity);
03449 #           endif
03450             iopc_inv = (float)1. - iopc;
03451             ;
03452             iopc += acc_opc * iopc_inv;
03453             ipixel->opcflt = iopc;
03454             
03455 #ifdef DEBUG
03456     if (ipixel == trace_pixel_ptr) {
03457 #ifdef COMPUTE_SHADOW_BUFFER
03458         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03459 #else
03460         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03461 #endif
03462         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03463         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03464         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03465         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03466         printf("  %3.0f %3.0f\n", iopc*255., 
03467                0);
03468         
03469         
03470     }
03471 #endif /* DEBUG */
03472 ;
03473 #           ifndef SKIP_ERT
03474                 if (iopc >= max_opacity) {
03475                     ASSERT(ipixel->lnk == 0);
03476                     ipixel->lnk = 1;
03477                 }
03478 #           endif
03479         };
03480                 ipixel += 1;
03481                 topRLEdata += 1 * voxel_istride;
03482                 botRLEdata += 1 * voxel_istride;
03483                 count--;
03484                 SET_VOXELS_LOADED;
03485                     
03486                 /* do the rest of the pixels in this run;
03487                    all four voxels contribute */
03488                 while (count > 0) {
03489                     if (PIXEL_IS_OPAQUE(ipixel))
03490                         break;
03491                     if (!voxels_loaded) {
03492                         
03493     
03494             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03495             opacity = param0_table[opac_param];
03496             if (param1_size != 0) {
03497                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03498                 opacity *= param1_table[opac_param];
03499                 if (param2_size != 0) {
03500                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03501                     opacity *= param2_table[opac_param];
03502                 }
03503             }
03504             if (opacity > min_opacity) {
03505                 opacity_int = opacity*255.;
03506                 top_opc = opac_correct[opacity_int];
03507             } else {
03508                 top_opc = (float)0.;
03509             };
03510     
03511     ;
03512                         
03513     
03514             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03515             opacity = param0_table[opac_param];
03516             if (param1_size != 0) {
03517                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03518                 opacity *= param1_table[opac_param];
03519                 if (param2_size != 0) {
03520                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03521                     opacity *= param2_table[opac_param];
03522                 }
03523             }
03524             if (opacity > min_opacity) {
03525                 opacity_int = opacity*255.;
03526                 bot_opc = opac_correct[opacity_int];
03527             } else {
03528                 bot_opc = (float)0.;
03529             };
03530     
03531     ;
03532                     }
03533                     
03534 #ifdef DEBUG
03535     if (ipixel == trace_pixel_ptr) {
03536         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03537         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03538         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03539         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03540         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03541     }
03542 #endif
03543 ;
03544                     
03545        acc_opc = top_opc * wgtTL;
03546        ;
03547        
03548 #ifdef DEBUG
03549     if (ipixel == trace_pixel_ptr) {
03550         trace_opcTL = top_opc;
03551         
03552         
03553     }
03554 #endif
03555 ;
03556                     
03557        acc_opc += bot_opc * wgtBL;
03558        ;
03559        
03560 #ifdef DEBUG
03561     if (ipixel == trace_pixel_ptr) {
03562         trace_opcBL = bot_opc;
03563         
03564         
03565     }
03566 #endif
03567 ;
03568                     
03569     
03570             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03571             opacity = param0_table[opac_param];
03572             if (param1_size != 0) {
03573                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03574                 opacity *= param1_table[opac_param];
03575                 if (param2_size != 0) {
03576                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03577                     opacity *= param2_table[opac_param];
03578                 }
03579             }
03580             if (opacity > min_opacity) {
03581                 opacity_int = opacity*255.;
03582                 top_opc = opac_correct[opacity_int];
03583             } else {
03584                 top_opc = (float)0.;
03585             };
03586     
03587     ;
03588                     
03589     
03590             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03591             opacity = param0_table[opac_param];
03592             if (param1_size != 0) {
03593                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03594                 opacity *= param1_table[opac_param];
03595                 if (param2_size != 0) {
03596                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03597                     opacity *= param2_table[opac_param];
03598                 }
03599             }
03600             if (opacity > min_opacity) {
03601                 opacity_int = opacity*255.;
03602                 bot_opc = opac_correct[opacity_int];
03603             } else {
03604                 bot_opc = (float)0.;
03605             };
03606     
03607     ;
03608                     
03609        acc_opc += top_opc * wgtTR;
03610        ;
03611        
03612 #ifdef DEBUG
03613     if (ipixel == trace_pixel_ptr) {
03614         trace_opcTR = top_opc;
03615         
03616         
03617     }
03618 #endif
03619 ;
03620                     
03621        acc_opc += bot_opc * wgtBR;
03622        ;
03623        
03624 #ifdef DEBUG
03625     if (ipixel == trace_pixel_ptr) {
03626         trace_opcBR = bot_opc;
03627         
03628         
03629     }
03630 #endif
03631 ;
03632                     
03633         COUNT_RESAMPLE;
03634         if (acc_opc > min_opacity) {
03635             COUNT_COMPOSITE;
03636             iopc = ipixel->opcflt;
03637 #           ifndef SKIP_ERT
03638                 ASSERT(iopc < max_opacity);
03639 #           endif
03640             iopc_inv = (float)1. - iopc;
03641             ;
03642             iopc += acc_opc * iopc_inv;
03643             ipixel->opcflt = iopc;
03644             
03645 #ifdef DEBUG
03646     if (ipixel == trace_pixel_ptr) {
03647 #ifdef COMPUTE_SHADOW_BUFFER
03648         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03649 #else
03650         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03651 #endif
03652         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03653         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03654         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03655         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03656         printf("  %3.0f %3.0f\n", iopc*255., 
03657                0);
03658         
03659         
03660     }
03661 #endif /* DEBUG */
03662 ;
03663 #           ifndef SKIP_ERT
03664                 if (iopc >= max_opacity) {
03665                     ASSERT(ipixel->lnk == 0);
03666                     ipixel->lnk = 1;
03667                 }
03668 #           endif
03669         };
03670                     ipixel += 1;
03671                     topRLEdata += 1 * voxel_istride;
03672                     botRLEdata += 1 * voxel_istride;
03673                     count--;
03674                     SET_VOXELS_LOADED;
03675                 }
03676                 break;
03677             case BOT_NONZERO__ALL_NONZERO:
03678                 /* first pixel: bottom-left, top-right and bottom-right
03679                    voxels contribute */
03680                 if (!voxels_loaded) {
03681                     
03682     
03683             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03684             opacity = param0_table[opac_param];
03685             if (param1_size != 0) {
03686                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03687                 opacity *= param1_table[opac_param];
03688                 if (param2_size != 0) {
03689                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03690                     opacity *= param2_table[opac_param];
03691                 }
03692             }
03693             if (opacity > min_opacity) {
03694                 opacity_int = opacity*255.;
03695                 bot_opc = opac_correct[opacity_int];
03696             } else {
03697                 bot_opc = (float)0.;
03698             };
03699     
03700     ;
03701                 }
03702                 
03703 #ifdef DEBUG
03704     if (ipixel == trace_pixel_ptr) {
03705         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03706         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03707         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03708         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03709         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03710     }
03711 #endif
03712 ;
03713                 
03714        acc_opc = bot_opc * wgtBL;
03715        ;
03716        
03717 #ifdef DEBUG
03718     if (ipixel == trace_pixel_ptr) {
03719         trace_opcBL = bot_opc;
03720         
03721         
03722     }
03723 #endif
03724 ;
03725                 
03726     
03727             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03728             opacity = param0_table[opac_param];
03729             if (param1_size != 0) {
03730                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03731                 opacity *= param1_table[opac_param];
03732                 if (param2_size != 0) {
03733                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03734                     opacity *= param2_table[opac_param];
03735                 }
03736             }
03737             if (opacity > min_opacity) {
03738                 opacity_int = opacity*255.;
03739                 top_opc = opac_correct[opacity_int];
03740             } else {
03741                 top_opc = (float)0.;
03742             };
03743     
03744     ;
03745                 
03746     
03747             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03748             opacity = param0_table[opac_param];
03749             if (param1_size != 0) {
03750                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03751                 opacity *= param1_table[opac_param];
03752                 if (param2_size != 0) {
03753                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03754                     opacity *= param2_table[opac_param];
03755                 }
03756             }
03757             if (opacity > min_opacity) {
03758                 opacity_int = opacity*255.;
03759                 bot_opc = opac_correct[opacity_int];
03760             } else {
03761                 bot_opc = (float)0.;
03762             };
03763     
03764     ;
03765                 
03766        acc_opc += top_opc * wgtTR;
03767        ;
03768        
03769 #ifdef DEBUG
03770     if (ipixel == trace_pixel_ptr) {
03771         trace_opcTR = top_opc;
03772         
03773         
03774     }
03775 #endif
03776 ;
03777                 
03778        acc_opc += bot_opc * wgtBR;
03779        ;
03780        
03781 #ifdef DEBUG
03782     if (ipixel == trace_pixel_ptr) {
03783         trace_opcBR = bot_opc;
03784         
03785         
03786     }
03787 #endif
03788 ;
03789                 
03790         COUNT_RESAMPLE;
03791         if (acc_opc > min_opacity) {
03792             COUNT_COMPOSITE;
03793             iopc = ipixel->opcflt;
03794 #           ifndef SKIP_ERT
03795                 ASSERT(iopc < max_opacity);
03796 #           endif
03797             iopc_inv = (float)1. - iopc;
03798             ;
03799             iopc += acc_opc * iopc_inv;
03800             ipixel->opcflt = iopc;
03801             
03802 #ifdef DEBUG
03803     if (ipixel == trace_pixel_ptr) {
03804 #ifdef COMPUTE_SHADOW_BUFFER
03805         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03806 #else
03807         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03808 #endif
03809         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03810         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03811         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03812         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03813         printf("  %3.0f %3.0f\n", iopc*255., 
03814                0);
03815         
03816         
03817     }
03818 #endif /* DEBUG */
03819 ;
03820 #           ifndef SKIP_ERT
03821                 if (iopc >= max_opacity) {
03822                     ASSERT(ipixel->lnk == 0);
03823                     ipixel->lnk = 1;
03824                 }
03825 #           endif
03826         };
03827                 ipixel += 1;
03828                 topRLEdata += 1 * voxel_istride;
03829                 botRLEdata += 1 * voxel_istride;
03830                 count--;
03831                 SET_VOXELS_LOADED;
03832                     
03833                 /* do the rest of the pixels in this run;
03834                    all four voxels contribute */
03835                 while (count > 0) {
03836                     if (PIXEL_IS_OPAQUE(ipixel))
03837                         break;
03838                     if (!voxels_loaded) {
03839                         
03840     
03841             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03842             opacity = param0_table[opac_param];
03843             if (param1_size != 0) {
03844                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03845                 opacity *= param1_table[opac_param];
03846                 if (param2_size != 0) {
03847                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03848                     opacity *= param2_table[opac_param];
03849                 }
03850             }
03851             if (opacity > min_opacity) {
03852                 opacity_int = opacity*255.;
03853                 top_opc = opac_correct[opacity_int];
03854             } else {
03855                 top_opc = (float)0.;
03856             };
03857     
03858     ;
03859                         
03860     
03861             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03862             opacity = param0_table[opac_param];
03863             if (param1_size != 0) {
03864                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03865                 opacity *= param1_table[opac_param];
03866                 if (param2_size != 0) {
03867                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03868                     opacity *= param2_table[opac_param];
03869                 }
03870             }
03871             if (opacity > min_opacity) {
03872                 opacity_int = opacity*255.;
03873                 bot_opc = opac_correct[opacity_int];
03874             } else {
03875                 bot_opc = (float)0.;
03876             };
03877     
03878     ;
03879                     }
03880                     
03881 #ifdef DEBUG
03882     if (ipixel == trace_pixel_ptr) {
03883         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03884         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03885         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03886         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03887         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03888     }
03889 #endif
03890 ;
03891                     
03892        acc_opc = top_opc * wgtTL;
03893        ;
03894        
03895 #ifdef DEBUG
03896     if (ipixel == trace_pixel_ptr) {
03897         trace_opcTL = top_opc;
03898         
03899         
03900     }
03901 #endif
03902 ;
03903                     
03904        acc_opc += bot_opc * wgtBL;
03905        ;
03906        
03907 #ifdef DEBUG
03908     if (ipixel == trace_pixel_ptr) {
03909         trace_opcBL = bot_opc;
03910         
03911         
03912     }
03913 #endif
03914 ;
03915                     
03916     
03917             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
03918             opacity = param0_table[opac_param];
03919             if (param1_size != 0) {
03920                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
03921                 opacity *= param1_table[opac_param];
03922                 if (param2_size != 0) {
03923                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
03924                     opacity *= param2_table[opac_param];
03925                 }
03926             }
03927             if (opacity > min_opacity) {
03928                 opacity_int = opacity*255.;
03929                 top_opc = opac_correct[opacity_int];
03930             } else {
03931                 top_opc = (float)0.;
03932             };
03933     
03934     ;
03935                     
03936     
03937             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03938             opacity = param0_table[opac_param];
03939             if (param1_size != 0) {
03940                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03941                 opacity *= param1_table[opac_param];
03942                 if (param2_size != 0) {
03943                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03944                     opacity *= param2_table[opac_param];
03945                 }
03946             }
03947             if (opacity > min_opacity) {
03948                 opacity_int = opacity*255.;
03949                 bot_opc = opac_correct[opacity_int];
03950             } else {
03951                 bot_opc = (float)0.;
03952             };
03953     
03954     ;
03955                     
03956        acc_opc += top_opc * wgtTR;
03957        ;
03958        
03959 #ifdef DEBUG
03960     if (ipixel == trace_pixel_ptr) {
03961         trace_opcTR = top_opc;
03962         
03963         
03964     }
03965 #endif
03966 ;
03967                     
03968        acc_opc += bot_opc * wgtBR;
03969        ;
03970        
03971 #ifdef DEBUG
03972     if (ipixel == trace_pixel_ptr) {
03973         trace_opcBR = bot_opc;
03974         
03975         
03976     }
03977 #endif
03978 ;
03979                     
03980         COUNT_RESAMPLE;
03981         if (acc_opc > min_opacity) {
03982             COUNT_COMPOSITE;
03983             iopc = ipixel->opcflt;
03984 #           ifndef SKIP_ERT
03985                 ASSERT(iopc < max_opacity);
03986 #           endif
03987             iopc_inv = (float)1. - iopc;
03988             ;
03989             iopc += acc_opc * iopc_inv;
03990             ipixel->opcflt = iopc;
03991             
03992 #ifdef DEBUG
03993     if (ipixel == trace_pixel_ptr) {
03994 #ifdef COMPUTE_SHADOW_BUFFER
03995         printf("{%3d}  %3d %3d", k, icount-i-count, j);
03996 #else
03997         printf("[%3d]  %3d %3d", k, icount-i-count, j);
03998 #endif
03999         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04000         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04001         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04002         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04003         printf("  %3.0f %3.0f\n", iopc*255., 
04004                0);
04005         
04006         
04007     }
04008 #endif /* DEBUG */
04009 ;
04010 #           ifndef SKIP_ERT
04011                 if (iopc >= max_opacity) {
04012                     ASSERT(ipixel->lnk == 0);
04013                     ipixel->lnk = 1;
04014                 }
04015 #           endif
04016         };
04017                     ipixel += 1;
04018                     topRLEdata += 1 * voxel_istride;
04019                     botRLEdata += 1 * voxel_istride;
04020                     count--;
04021                     SET_VOXELS_LOADED;
04022                 }
04023                 break;
04024             case ALL_NONZERO__ALL_NONZERO:
04025                 /* do the pixels in this run; all four voxels contribute */
04026                 while (count > 0) {
04027                     if (PIXEL_IS_OPAQUE(ipixel))
04028                         break;
04029                     if (!voxels_loaded) {
04030                         
04031     
04032             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04033             opacity = param0_table[opac_param];
04034             if (param1_size != 0) {
04035                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04036                 opacity *= param1_table[opac_param];
04037                 if (param2_size != 0) {
04038                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04039                     opacity *= param2_table[opac_param];
04040                 }
04041             }
04042             if (opacity > min_opacity) {
04043                 opacity_int = opacity*255.;
04044                 top_opc = opac_correct[opacity_int];
04045             } else {
04046                 top_opc = (float)0.;
04047             };
04048     
04049     ;
04050                         
04051     
04052             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04053             opacity = param0_table[opac_param];
04054             if (param1_size != 0) {
04055                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04056                 opacity *= param1_table[opac_param];
04057                 if (param2_size != 0) {
04058                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04059                     opacity *= param2_table[opac_param];
04060                 }
04061             }
04062             if (opacity > min_opacity) {
04063                 opacity_int = opacity*255.;
04064                 bot_opc = opac_correct[opacity_int];
04065             } else {
04066                 bot_opc = (float)0.;
04067             };
04068     
04069     ;
04070                     }
04071                     
04072 #ifdef DEBUG
04073     if (ipixel == trace_pixel_ptr) {
04074         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04075         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04076         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04077         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04078         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04079     }
04080 #endif
04081 ;
04082                     
04083        acc_opc = top_opc * wgtTL;
04084        ;
04085        
04086 #ifdef DEBUG
04087     if (ipixel == trace_pixel_ptr) {
04088         trace_opcTL = top_opc;
04089         
04090         
04091     }
04092 #endif
04093 ;
04094                     
04095        acc_opc += bot_opc * wgtBL;
04096        ;
04097        
04098 #ifdef DEBUG
04099     if (ipixel == trace_pixel_ptr) {
04100         trace_opcBL = bot_opc;
04101         
04102         
04103     }
04104 #endif
04105 ;
04106                     
04107     
04108             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04109             opacity = param0_table[opac_param];
04110             if (param1_size != 0) {
04111                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04112                 opacity *= param1_table[opac_param];
04113                 if (param2_size != 0) {
04114                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04115                     opacity *= param2_table[opac_param];
04116                 }
04117             }
04118             if (opacity > min_opacity) {
04119                 opacity_int = opacity*255.;
04120                 top_opc = opac_correct[opacity_int];
04121             } else {
04122                 top_opc = (float)0.;
04123             };
04124     
04125     ;
04126                     
04127     
04128             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04129             opacity = param0_table[opac_param];
04130             if (param1_size != 0) {
04131                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04132                 opacity *= param1_table[opac_param];
04133                 if (param2_size != 0) {
04134                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04135                     opacity *= param2_table[opac_param];
04136                 }
04137             }
04138             if (opacity > min_opacity) {
04139                 opacity_int = opacity*255.;
04140                 bot_opc = opac_correct[opacity_int];
04141             } else {
04142                 bot_opc = (float)0.;
04143             };
04144     
04145     ;
04146                     
04147        acc_opc += top_opc * wgtTR;
04148        ;
04149        
04150 #ifdef DEBUG
04151     if (ipixel == trace_pixel_ptr) {
04152         trace_opcTR = top_opc;
04153         
04154         
04155     }
04156 #endif
04157 ;
04158                     
04159        acc_opc += bot_opc * wgtBR;
04160        ;
04161        
04162 #ifdef DEBUG
04163     if (ipixel == trace_pixel_ptr) {
04164         trace_opcBR = bot_opc;
04165         
04166         
04167     }
04168 #endif
04169 ;
04170                     
04171         COUNT_RESAMPLE;
04172         if (acc_opc > min_opacity) {
04173             COUNT_COMPOSITE;
04174             iopc = ipixel->opcflt;
04175 #           ifndef SKIP_ERT
04176                 ASSERT(iopc < max_opacity);
04177 #           endif
04178             iopc_inv = (float)1. - iopc;
04179             ;
04180             iopc += acc_opc * iopc_inv;
04181             ipixel->opcflt = iopc;
04182             
04183 #ifdef DEBUG
04184     if (ipixel == trace_pixel_ptr) {
04185 #ifdef COMPUTE_SHADOW_BUFFER
04186         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04187 #else
04188         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04189 #endif
04190         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04191         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04192         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04193         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04194         printf("  %3.0f %3.0f\n", iopc*255., 
04195                0);
04196         
04197         
04198     }
04199 #endif /* DEBUG */
04200 ;
04201 #           ifndef SKIP_ERT
04202                 if (iopc >= max_opacity) {
04203                     ASSERT(ipixel->lnk == 0);
04204                     ipixel->lnk = 1;
04205                 }
04206 #           endif
04207         };
04208                     ipixel += 1;
04209                     topRLEdata += 1 * voxel_istride;
04210                     botRLEdata += 1 * voxel_istride;
04211                     count--;
04212                     SET_VOXELS_LOADED;
04213                 }
04214                 break;
04215             default:
04216                 VPBug("illegal value for run states in compositing loop");
04217             }
04218 #else /* UNROLL_RUN_LOOP */
04219             /* this run contains pixels, so process them */
04220             while (count > 0) {
04221                 if (last_run_state == ALL_ZERO && run_state == ALL_ZERO) {
04222                     ipixel += count;
04223                     if (i != -1) {
04224                         topRLEdata += count * voxel_istride;
04225                         botRLEdata += count * voxel_istride;
04226                     }
04227                     count = 0;
04228                     break;
04229                 }
04230                 if (ipixel->lnk != 0)
04231                     break;
04232                 
04233 #ifdef DEBUG
04234     if (ipixel == trace_pixel_ptr) {
04235         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04236         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04237         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04238         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04239         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04240     }
04241 #endif
04242 ;
04243                 
04244        acc_opc = 0;
04245        ;
04246                 if (last_run_state & TOP_NONZERO) {
04247                     if (!voxels_loaded) {
04248                         
04249     
04250             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04251             opacity = param0_table[opac_param];
04252             if (param1_size != 0) {
04253                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04254                 opacity *= param1_table[opac_param];
04255                 if (param2_size != 0) {
04256                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04257                     opacity *= param2_table[opac_param];
04258                 }
04259             }
04260             if (opacity > min_opacity) {
04261                 opacity_int = opacity*255.;
04262                 top_opc = opac_correct[opacity_int];
04263             } else {
04264                 top_opc = (float)0.;
04265             };
04266     
04267     ;
04268                     }
04269                     
04270        acc_opc += top_opc * wgtTL;
04271        ;
04272        
04273 #ifdef DEBUG
04274     if (ipixel == trace_pixel_ptr) {
04275         trace_opcTL = top_opc;
04276         
04277         
04278     }
04279 #endif
04280 ;
04281                 }
04282                 if (last_run_state & BOT_NONZERO) {
04283                     if (!voxels_loaded) {
04284                         
04285     
04286             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04287             opacity = param0_table[opac_param];
04288             if (param1_size != 0) {
04289                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04290                 opacity *= param1_table[opac_param];
04291                 if (param2_size != 0) {
04292                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04293                     opacity *= param2_table[opac_param];
04294                 }
04295             }
04296             if (opacity > min_opacity) {
04297                 opacity_int = opacity*255.;
04298                 bot_opc = opac_correct[opacity_int];
04299             } else {
04300                 bot_opc = (float)0.;
04301             };
04302     
04303     ;
04304                     }
04305                     
04306        acc_opc += bot_opc * wgtBL;
04307        ;
04308        
04309 #ifdef DEBUG
04310     if (ipixel == trace_pixel_ptr) {
04311         trace_opcBL = bot_opc;
04312         
04313         
04314     }
04315 #endif
04316 ;
04317                 }
04318                 if (run_state & TOP_NONZERO) {
04319                     
04320     
04321             opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04322             opacity = param0_table[opac_param];
04323             if (param1_size != 0) {
04324                 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04325                 opacity *= param1_table[opac_param];
04326                 if (param2_size != 0) {
04327                     opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04328                     opacity *= param2_table[opac_param];
04329                 }
04330             }
04331             if (opacity > min_opacity) {
04332                 opacity_int = opacity*255.;
04333                 top_opc = opac_correct[opacity_int];
04334             } else {
04335                 top_opc = (float)0.;
04336             };
04337     
04338     ;
04339                     
04340        acc_opc += top_opc * wgtTR;
04341        ;
04342        
04343 #ifdef DEBUG
04344     if (ipixel == trace_pixel_ptr) {
04345         trace_opcTR = top_opc;
04346         
04347         
04348     }
04349 #endif
04350 ;
04351                     topRLEdata += 1 * voxel_istride;
04352                 } else {
04353                     if (i != -1) {
04354                         topRLEdata += 1 * voxel_istride;
04355                     }
04356                 }
04357                 if (run_state & BOT_NONZERO) {
04358                     
04359     
04360             opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04361             opacity = param0_table[opac_param];
04362             if (param1_size != 0) {
04363                 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04364                 opacity *= param1_table[opac_param];
04365                 if (param2_size != 0) {
04366                     opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04367                     opacity *= param2_table[opac_param];
04368                 }
04369             }
04370             if (opacity > min_opacity) {
04371                 opacity_int = opacity*255.;
04372                 bot_opc = opac_correct[opacity_int];
04373             } else {
04374                 bot_opc = (float)0.;
04375             };
04376     
04377     ;
04378                     
04379        acc_opc += bot_opc * wgtBR;
04380        ;
04381        
04382 #ifdef DEBUG
04383     if (ipixel == trace_pixel_ptr) {
04384         trace_opcBR = bot_opc;
04385         
04386         
04387     }
04388 #endif
04389 ;
04390                     botRLEdata += 1 * voxel_istride;
04391                 } else {
04392                     if (i != -1) {
04393                         botRLEdata += 1 * voxel_istride;
04394                     }
04395                 }
04396                 
04397         COUNT_RESAMPLE;
04398         if (acc_opc > min_opacity) {
04399             COUNT_COMPOSITE;
04400             iopc = ipixel->opcflt;
04401 #           ifndef SKIP_ERT
04402                 ASSERT(iopc < max_opacity);
04403 #           endif
04404             iopc_inv = (float)1. - iopc;
04405             ;
04406             iopc += acc_opc * iopc_inv;
04407             ipixel->opcflt = iopc;
04408             
04409 #ifdef DEBUG
04410     if (ipixel == trace_pixel_ptr) {
04411 #ifdef COMPUTE_SHADOW_BUFFER
04412         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04413 #else
04414         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04415 #endif
04416         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04417         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04418         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04419         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04420         printf("  %3.0f %3.0f\n", iopc*255., 
04421                0);
04422         
04423         
04424     }
04425 #endif /* DEBUG */
04426 ;
04427 #           ifndef SKIP_ERT
04428                 if (iopc >= max_opacity) {
04429                     ASSERT(ipixel->lnk == 0);
04430                     ipixel->lnk = 1;
04431                 }
04432 #           endif
04433         };
04434                 ipixel += 1;
04435                 count--;
04436                 SET_VOXELS_LOADED;
04437                 last_run_state = run_state;
04438             }
04439 #endif /* UNROLL_RUN_LOOP */
04440 
04441             GET_HIRES_TIME(vpc, t1);
04442             STORE_HIRES_TIME(vpc, VPTIMER_PROCESS_VOXELS, t0, t1);
04443             COPY_HIRES_TIME(t0, t1);
04444 
04445             if (count > 0) {
04446                 Debug((vpc, VPDEBUG_COMPOSITE, "Backup(%d)\n", count));
04447                 toprun_count += count;
04448                 botrun_count += count;
04449                 i += count;
04450             }
04451 #endif /* SKIP_COMPOSITE */
04452 
04453             /***********************************************************
04454              * Go on to next voxel run.
04455              ***********************************************************/
04456 
04457             last_run_state = run_state;
04458         } /* while (i > 0) */
04459 
04460         /***************************************************************
04461          * Finish processing voxel scanline and go on to next one.
04462          ***************************************************************/
04463 
04464 #ifdef UNROLL_RUN_LOOP
04465         ASSERT(i == 0);
04466 #else
04467         ASSERT(i == -1);
04468 #endif
04469 
04470 #ifndef SKIP_COMPOSITE
04471 #ifdef UNROLL_RUN_LOOP
04472         /* do the last pixel (to the right of the last voxel) */
04473         if (last_run_state != ALL_ZERO && !PIXEL_IS_OPAQUE(ipixel)) {
04474             /* last voxels are nonzero and the pixel is not opaque yet
04475                so there is work to be done */
04476             Debug((vpc, VPDEBUG_COMPOSITE, "Run(1)End\n"));
04477             switch (last_run_state) {
04478             case TOP_NONZERO:
04479                 /* only the top-left voxel contributes */
04480                 if (!voxels_loaded) {
04481                     
04482     
04483             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04484             opacity = param0_table[opac_param];
04485             if (param1_size != 0) {
04486                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04487                 opacity *= param1_table[opac_param];
04488                 if (param2_size != 0) {
04489                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04490                     opacity *= param2_table[opac_param];
04491                 }
04492             }
04493             if (opacity > min_opacity) {
04494                 opacity_int = opacity*255.;
04495                 top_opc = opac_correct[opacity_int];
04496             } else {
04497                 top_opc = (float)0.;
04498             };
04499     
04500     ;
04501                 }
04502                 
04503 #ifdef DEBUG
04504     if (ipixel == trace_pixel_ptr) {
04505         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04506         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04507         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04508         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04509         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04510     }
04511 #endif
04512 ;
04513                 
04514        acc_opc = top_opc * wgtTL;
04515        ;
04516        
04517 #ifdef DEBUG
04518     if (ipixel == trace_pixel_ptr) {
04519         trace_opcTL = top_opc;
04520         
04521         
04522     }
04523 #endif
04524 ;
04525                 
04526         COUNT_RESAMPLE;
04527         if (acc_opc > min_opacity) {
04528             COUNT_COMPOSITE;
04529             iopc = ipixel->opcflt;
04530 #           ifndef SKIP_ERT
04531                 ASSERT(iopc < max_opacity);
04532 #           endif
04533             iopc_inv = (float)1. - iopc;
04534             ;
04535             iopc += acc_opc * iopc_inv;
04536             ipixel->opcflt = iopc;
04537             
04538 #ifdef DEBUG
04539     if (ipixel == trace_pixel_ptr) {
04540 #ifdef COMPUTE_SHADOW_BUFFER
04541         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04542 #else
04543         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04544 #endif
04545         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04546         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04547         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04548         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04549         printf("  %3.0f %3.0f\n", iopc*255., 
04550                0);
04551         
04552         
04553     }
04554 #endif /* DEBUG */
04555 ;
04556 #           ifndef SKIP_ERT
04557                 if (iopc >= max_opacity) {
04558                     ASSERT(ipixel->lnk == 0);
04559                     ipixel->lnk = 1;
04560                 }
04561 #           endif
04562         };
04563                 break;
04564             case BOT_NONZERO:
04565                 /* only the bottom left voxel contributes */
04566                 if (!voxels_loaded) {
04567                     
04568     
04569             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04570             opacity = param0_table[opac_param];
04571             if (param1_size != 0) {
04572                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04573                 opacity *= param1_table[opac_param];
04574                 if (param2_size != 0) {
04575                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04576                     opacity *= param2_table[opac_param];
04577                 }
04578             }
04579             if (opacity > min_opacity) {
04580                 opacity_int = opacity*255.;
04581                 bot_opc = opac_correct[opacity_int];
04582             } else {
04583                 bot_opc = (float)0.;
04584             };
04585     
04586     ;
04587                 }
04588                 
04589 #ifdef DEBUG
04590     if (ipixel == trace_pixel_ptr) {
04591         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04592         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04593         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04594         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04595         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04596     }
04597 #endif
04598 ;
04599                 
04600        acc_opc = bot_opc * wgtBL;
04601        ;
04602        
04603 #ifdef DEBUG
04604     if (ipixel == trace_pixel_ptr) {
04605         trace_opcBL = bot_opc;
04606         
04607         
04608     }
04609 #endif
04610 ;
04611                 
04612         COUNT_RESAMPLE;
04613         if (acc_opc > min_opacity) {
04614             COUNT_COMPOSITE;
04615             iopc = ipixel->opcflt;
04616 #           ifndef SKIP_ERT
04617                 ASSERT(iopc < max_opacity);
04618 #           endif
04619             iopc_inv = (float)1. - iopc;
04620             ;
04621             iopc += acc_opc * iopc_inv;
04622             ipixel->opcflt = iopc;
04623             
04624 #ifdef DEBUG
04625     if (ipixel == trace_pixel_ptr) {
04626 #ifdef COMPUTE_SHADOW_BUFFER
04627         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04628 #else
04629         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04630 #endif
04631         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04632         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04633         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04634         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04635         printf("  %3.0f %3.0f\n", iopc*255., 
04636                0);
04637         
04638         
04639     }
04640 #endif /* DEBUG */
04641 ;
04642 #           ifndef SKIP_ERT
04643                 if (iopc >= max_opacity) {
04644                     ASSERT(ipixel->lnk == 0);
04645                     ipixel->lnk = 1;
04646                 }
04647 #           endif
04648         };
04649                 break;
04650             case ALL_NONZERO:
04651                 /* the top and bottom left voxels contribute */
04652                 if (!voxels_loaded) {
04653                     
04654     
04655             opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04656             opacity = param0_table[opac_param];
04657             if (param1_size != 0) {
04658                 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04659                 opacity *= param1_table[opac_param];
04660                 if (param2_size != 0) {
04661                     opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04662                     opacity *= param2_table[opac_param];
04663                 }
04664             }
04665             if (opacity > min_opacity) {
04666                 opacity_int = opacity*255.;
04667                 top_opc = opac_correct[opacity_int];
04668             } else {
04669                 top_opc = (float)0.;
04670             };
04671     
04672     ;
04673                     
04674     
04675             opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04676             opacity = param0_table[opac_param];
04677             if (param1_size != 0) {
04678                 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04679                 opacity *= param1_table[opac_param];
04680                 if (param2_size != 0) {
04681                     opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04682                     opacity *= param2_table[opac_param];
04683                 }
04684             }
04685             if (opacity > min_opacity) {
04686                 opacity_int = opacity*255.;
04687                 bot_opc = opac_correct[opacity_int];
04688             } else {
04689                 bot_opc = (float)0.;
04690             };
04691     
04692     ;
04693                 }
04694                 
04695 #ifdef DEBUG
04696     if (ipixel == trace_pixel_ptr) {
04697         trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04698         trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04699         trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04700         trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04701         trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04702     }
04703 #endif
04704 ;
04705                 
04706        acc_opc = top_opc * wgtTL;
04707        ;
04708        
04709 #ifdef DEBUG
04710     if (ipixel == trace_pixel_ptr) {
04711         trace_opcTL = top_opc;
04712         
04713         
04714     }
04715 #endif
04716 ;
04717                 
04718        acc_opc += bot_opc * wgtBL;
04719        ;
04720        
04721 #ifdef DEBUG
04722     if (ipixel == trace_pixel_ptr) {
04723         trace_opcBL = bot_opc;
04724         
04725         
04726     }
04727 #endif
04728 ;
04729                 
04730         COUNT_RESAMPLE;
04731         if (acc_opc > min_opacity) {
04732             COUNT_COMPOSITE;
04733             iopc = ipixel->opcflt;
04734 #           ifndef SKIP_ERT
04735                 ASSERT(iopc < max_opacity);
04736 #           endif
04737             iopc_inv = (float)1. - iopc;
04738             ;
04739             iopc += acc_opc * iopc_inv;
04740             ipixel->opcflt = iopc;
04741             
04742 #ifdef DEBUG
04743     if (ipixel == trace_pixel_ptr) {
04744 #ifdef COMPUTE_SHADOW_BUFFER
04745         printf("{%3d}  %3d %3d", k, icount-i-count, j);
04746 #else
04747         printf("[%3d]  %3d %3d", k, icount-i-count, j);
04748 #endif
04749         printf("  %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04750         printf("  %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04751         printf("  %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04752         printf("  %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04753         printf("  %3.0f %3.0f\n", iopc*255., 
04754                0);
04755         
04756         
04757     }
04758 #endif /* DEBUG */
04759 ;
04760 #           ifndef SKIP_ERT
04761                 if (iopc >= max_opacity) {
04762                     ASSERT(ipixel->lnk == 0);
04763                     ipixel->lnk = 1;
04764                 }
04765 #           endif
04766         };
04767                 break;
04768             default:
04769                 VPBug("illegal value for run state at end of scanline");
04770             }
04771         } else if (last_run_state == ALL_ZERO) {
04772             Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
04773         } else {
04774             Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
04775         }
04776 #endif /* UNROLL_RUN_LOOP */
04777 #endif /* SKIP_COMPOSITE */
04778 
04779 #ifndef UNROLL_RUN_LOOP
04780         run_state = final_run_state;
04781 #endif
04782         /* skip over any zero-length runs remaining in this scanline */
04783         if (j != 0 && ((run_state & 1) == 0)) {
04784             toprun_count = *topRLElen++;
04785             ASSERT(toprun_count == 0);
04786         }
04787         if (j != jcount && ((run_state & 2) == 0)) {
04788             botrun_count = *botRLElen++;
04789             ASSERT(botrun_count == 0);
04790         }
04791 
04792         /* go to next intermediate image scanline */
04793 #ifdef UNROLL_RUN_LOOP
04794         ipixel += intermediate_width - icount;
04795 #ifdef USE_SHADOW_BUFFER
04796         shadow_pixel += shadow_width - icount;
04797 #endif
04798 #else /* UNROLL_RUN_LOOP */
04799         ipixel += intermediate_width - (icount+1);
04800 #ifdef USE_SHADOW_BUFFER
04801         shadow_pixel += shadow_width - (icount+1);
04802 #endif
04803 #endif /* UNROLL_RUN_LOOP */
04804 
04805         Debug((vpc, VPDEBUG_COMPOSITE, "ScanDone\n"));
04806     } /* for j */
04807 
04808     /***************************************************************
04809      * Finish processing the voxel slice.
04810      ***************************************************************/
04811 
04812     GET_HIRES_TIME(vpc, t1);
04813     STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
04814 
04815     Debug((vpc, VPDEBUG_COMPOSITE, "SliceDone\n"));
04816 }
AFNI/NIfTI Server

Sections

Personal tools

Navigation

Doxygen Source Code Documentation

vp_compAR00G.c
