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