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