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 #define USE_SHADOW_BUFFER
00069
00070
00071
00072
00073
00074 #undef UNROLL_RUN_LOOP
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095 #define MULTIPLE_MATERIALS
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 #define GRAYSCALE
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137 #define RAWVOLUME
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147 #undef INDEX_VOLUME
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161 #define ALL_ZERO 0
00162 #define TOP_NONZERO 1
00163 #define BOT_NONZERO 2
00164 #define ALL_NONZERO 3
00165
00166
00167 #define ALL_ZERO__ALL_ZERO ((ALL_ZERO << 2) | ALL_ZERO)
00168 #define ALL_ZERO__TOP_NONZERO ((ALL_ZERO << 2) | TOP_NONZERO)
00169 #define ALL_ZERO__BOT_NONZERO ((ALL_ZERO << 2) | BOT_NONZERO)
00170 #define ALL_ZERO__ALL_NONZERO ((ALL_ZERO << 2) | ALL_NONZERO)
00171 #define TOP_NONZERO__ALL_ZERO ((TOP_NONZERO << 2) | ALL_ZERO)
00172 #define TOP_NONZERO__TOP_NONZERO ((TOP_NONZERO << 2) | TOP_NONZERO)
00173 #define TOP_NONZERO__BOT_NONZERO ((TOP_NONZERO << 2) | BOT_NONZERO)
00174 #define TOP_NONZERO__ALL_NONZERO ((TOP_NONZERO << 2) | ALL_NONZERO)
00175 #define BOT_NONZERO__ALL_ZERO ((BOT_NONZERO << 2) | ALL_ZERO)
00176 #define BOT_NONZERO__TOP_NONZERO ((BOT_NONZERO << 2) | TOP_NONZERO)
00177 #define BOT_NONZERO__BOT_NONZERO ((BOT_NONZERO << 2) | BOT_NONZERO)
00178 #define BOT_NONZERO__ALL_NONZERO ((BOT_NONZERO << 2) | ALL_NONZERO)
00179 #define ALL_NONZERO__ALL_ZERO ((ALL_NONZERO << 2) | ALL_ZERO)
00180 #define ALL_NONZERO__TOP_NONZERO ((ALL_NONZERO << 2) | TOP_NONZERO)
00181 #define ALL_NONZERO__BOT_NONZERO ((ALL_NONZERO << 2) | BOT_NONZERO)
00182 #define ALL_NONZERO__ALL_NONZERO ((ALL_NONZERO << 2) | ALL_NONZERO)
00183
00184 #ifdef SKIP_ERT
00185 #define PIXEL_IS_OPAQUE(ipixel) 0
00186 #else
00187 #define PIXEL_IS_OPAQUE(ipixel) ((ipixel)->lnk != 0)
00188 #endif
00189
00190 #ifdef STATISTICS
00191 extern int vpResampleCount;
00192 extern int vpCompositeCount;
00193 extern int vpERTSkipCount;
00194 extern int vpERTSkipAgainCount;
00195 extern int vpERTUpdateCount;
00196 extern int vpSpecialZeroSkipCount;
00197 extern int vpRunFragmentCount;
00198 #define COUNT_RESAMPLE vpResampleCount++
00199 #define COUNT_COMPOSITE vpCompositeCount++
00200 #define COUNT_ERT_SKIP vpERTSkipCount++
00201 #define COUNT_ERT_SKIP_AGAIN vpERTSkipAgainCount++
00202 #define COUNT_ERT_UPDATE vpERTUpdateCount++
00203 #define COUNT_SPECIAL_ZERO_SKIP vpSpecialZeroSkipCount++
00204 #define COUNT_RUN_FRAGMENT vpRunFragmentCount++
00205 #else
00206 #define COUNT_RESAMPLE
00207 #define COUNT_COMPOSITE
00208 #define COUNT_ERT_SKIP
00209 #define COUNT_ERT_SKIP_AGAIN
00210 #define COUNT_ERT_UPDATE
00211 #define COUNT_SPECIAL_ZERO_SKIP
00212 #define COUNT_RUN_FRAGMENT
00213 #endif
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223 void
00224 VPCompAR1NS (vpc, icount, jcount, k, slice_depth_cueing_dbl, intimage,
00225 weightTLdbl, weightBLdbl, weightTRdbl, weightBRdbl,
00226 voxel_data, voxel_istride, voxel_jstride , shadow_buffer)
00227 vpContext *vpc;
00228 int icount;
00229 int jcount;
00230 int k;
00231 double slice_depth_cueing_dbl;
00232 GrayIntPixel *intimage;
00233 double weightTLdbl;
00234 double weightBLdbl;
00235 double weightTRdbl;
00236 double weightBRdbl;
00237
00238 void *voxel_data;
00239 int voxel_istride;
00240 int voxel_jstride;
00241 GrayIntPixel *shadow_buffer;
00242 {
00243 int i, j;
00244 GrayIntPixel *ipixel;
00245 GrayIntPixel *ipixel2;
00246 int update_interval;
00247 float iopc;
00248 float iopc_inv;
00249 float acc_opc;
00250 float top_opc, bot_opc;
00251 #ifdef NO_REUSE_VOXEL
00252 #define voxels_loaded 0
00253 #define CLEAR_VOXELS_LOADED
00254 #define SET_VOXELS_LOADED
00255 #else
00256 int voxels_loaded;
00257
00258 #define CLEAR_VOXELS_LOADED voxels_loaded = 0
00259 #define SET_VOXELS_LOADED voxels_loaded = 1
00260 #endif
00261 float wgtTL, wgtBL,
00262 wgtTR, wgtBR;
00263
00264
00265 unsigned char *topRLElen;
00266 unsigned char *botRLElen;
00267 char *topRLEdata;
00268 char *botRLEdata;
00269 int toprun_count;
00270 int botrun_count;
00271 int last_run_state;
00272 int run_state;
00273 int final_run_state;
00274 float min_opacity;
00275 float max_opacity;
00276 float slice_depth_cueing;
00277 float *opac_correct;
00278 int ert_skip_count;
00279 int intermediate_width;
00280 int count;
00281 float *shade_table;
00282 int norm_offset;
00283 int shade_index;
00284 float shade_factor;
00285
00286
00287 #ifdef MULTIPLE_MATERIALS
00288 float *weight_table;
00289 int wgt_offset;
00290 int weight_index;
00291 int m, num_materials;
00292 float weight1, weight2;
00293 #endif
00294
00295 #ifdef GRAYSCALE
00296 float acc_clr;
00297 float top_clr, bot_clr;
00298 #endif
00299
00300 #ifdef RGB
00301 float acc_rclr;
00302 float acc_gclr;
00303 float acc_bclr;
00304 float top_rclr;
00305 float bot_rclr;
00306 float top_gclr;
00307 float bot_gclr;
00308 float top_bclr;
00309 float bot_bclr;
00310 #endif
00311
00312 #ifdef RLEVOLUME
00313 int voxel_istride;
00314 #endif
00315
00316 #ifdef RAWVOLUME
00317 int use_octree;
00318 MMOctreeLevel level_stack[VP_MAX_OCTREE_LEVELS];
00319
00320 int scans_left;
00321 int best_view_axis;
00322 unsigned char runlen_buf1[VP_MAX_VOLUME_DIM];
00323 unsigned char runlen_buf2[VP_MAX_VOLUME_DIM];
00324 unsigned char *top_len_base;
00325 unsigned char *bot_len_base;
00326 int opac_param;
00327 float opacity;
00328 int opacity_int;
00329 int param0_offset;
00330 int param0_size;
00331 float *param0_table;
00332 int param1_offset;
00333 int param1_size;
00334 float *param1_table;
00335 int param2_offset;
00336 int param2_size;
00337 float *param2_table;
00338 #endif
00339
00340 #ifdef INDEX_VOLUME
00341 unsigned char *scanline_topRLElen;
00342 unsigned char *scanline_botRLElen;
00343 char *scanline_topRLEdata;
00344 char *scanline_botRLEdata;
00345 VoxelLocation *top_voxel_index;
00346 VoxelLocation *bot_voxel_index;
00347 VoxelLocation *vindex;
00348 int next_i;
00349 int next_scan;
00350 #endif
00351
00352 #ifdef CALLBACK
00353
00354 #ifdef GRAYSCALE
00355 void (*shade_func) ANSI_ARGS((void *, float *, void *));
00356 #endif
00357 #ifdef RGB
00358 void (*shade_func) ANSI_ARGS((void *, float *, float *, float *, void *));
00359 #endif
00360 void *client_data;
00361 #endif
00362
00363 #ifdef USE_SHADOW_BUFFER
00364 float *shadow_table;
00365 int shadow_width;
00366 GrayIntPixel *shadow_pixel;
00367 #ifdef GRAYSCALE
00368 float top_sclr, bot_sclr;
00369 #endif
00370 #ifdef RGB
00371 float top_rsclr;
00372 float bot_rsclr;
00373 float top_gsclr;
00374 float bot_gsclr;
00375 float top_bsclr;
00376 float bot_bsclr;
00377 #endif
00378 #endif
00379
00380 #ifdef DEBUG
00381 float trace_opcTL, trace_opcBL, trace_opcTR, trace_opcBR;
00382 float trace_rsclrTL, trace_rsclrBL, trace_rsclrTR, trace_rsclrBR;
00383 float trace_rclrTL, trace_rclrBL, trace_rclrTR, trace_rclrBR;
00384 float trace_gclrTL, trace_gclrBL, trace_gclrTR, trace_gclrBR;
00385 float trace_bclrTL, trace_bclrBL, trace_bclrTR, trace_bclrBR;
00386 GrayIntPixel *trace_pixel_ptr;
00387
00388 #ifdef COMPUTE_SHADOW_BUFFER
00389 int slice_u_int, shadow_slice_u_int;
00390 int slice_v_int, shadow_slice_v_int;
00391 #endif
00392 #endif
00393
00394 DECLARE_HIRES_TIME(t0);
00395 DECLARE_HIRES_TIME(t1);
00396
00397
00398
00399
00400
00401 GET_HIRES_TIME(vpc, t0);
00402
00403 wgtTL = weightTLdbl;
00404 wgtBL = weightBLdbl;
00405 wgtTR = weightTRdbl;
00406 wgtBR = weightBRdbl;
00407 slice_depth_cueing = slice_depth_cueing_dbl;
00408 min_opacity = vpc->min_opacity;
00409 max_opacity = vpc->max_opacity;
00410 #ifdef USE_SHADOW_BUFFER
00411 opac_correct = vpc->shadow_opac_correct;
00412 #else
00413 opac_correct = vpc->affine_opac_correct;
00414 #endif
00415 #ifdef COMPUTE_SHADOW_BUFFER
00416 intermediate_width = vpc->shadow_width;
00417 #else
00418 intermediate_width = vpc->intermediate_width;
00419 #endif
00420 #ifdef USE_SHADOW_BUFFER
00421 shadow_table = vpc->shadow_color_table;
00422 shadow_width = vpc->shadow_width;
00423 shadow_pixel = shadow_buffer;
00424 #endif
00425 ipixel = intimage;
00426 shade_table = vpc->shade_color_table;
00427 norm_offset = vpc->field_offset[vpc->color_field];
00428
00429 #ifdef MULTIPLE_MATERIALS
00430 weight_table = vpc->shade_weight_table;
00431 wgt_offset = vpc->field_offset[vpc->weight_field];
00432 num_materials = vpc->num_materials;
00433 #endif
00434
00435 #ifdef RLEVOLUME
00436 topRLEdata = voxel_data;
00437 botRLEdata = voxel_data;
00438 topRLElen = run_lengths;
00439 botRLElen = run_lengths;
00440 voxel_istride = vpc->rle_bytes_per_voxel;
00441 #endif
00442
00443 #ifdef RAWVOLUME
00444 ASSERT(vpc->num_clsfy_params > 0);
00445 ASSERT(vpc->num_clsfy_params < 3);
00446 param0_offset = vpc->field_offset[vpc->param_field[0]];
00447 param0_size = vpc->field_size[vpc->param_field[0]];
00448 param0_table = vpc->clsfy_table[0];
00449 if (vpc->num_clsfy_params > 1) {
00450 param1_offset = vpc->field_offset[vpc->param_field[1]];
00451 param1_size = vpc->field_size[vpc->param_field[1]];
00452 param1_table = vpc->clsfy_table[1];
00453 } else {
00454 param1_offset = 0;
00455 param1_size = 0;
00456 param1_table = NULL;
00457 }
00458 if (vpc->num_clsfy_params > 2) {
00459 param2_offset = vpc->field_offset[vpc->param_field[2]];
00460 param2_size = vpc->field_size[vpc->param_field[2]];
00461 param2_table = vpc->clsfy_table[2];
00462 } else {
00463 param2_offset = 0;
00464 param2_size = 0;
00465 param2_table = NULL;
00466 }
00467 if (vpc->mm_octree == NULL) {
00468 use_octree = 0;
00469 } else {
00470 use_octree = 1;
00471 best_view_axis = vpc->best_view_axis;
00472 VPInitOctreeLevelStack(vpc, level_stack, best_view_axis, k);
00473 scans_left = 0;
00474 bot_len_base = runlen_buf1;
00475 }
00476 #endif
00477
00478 #ifdef CALLBACK
00479 shade_func = vpc->shade_func;
00480 client_data = vpc->client_data;
00481 ASSERT(shade_func != NULL);
00482 #endif
00483
00484 #ifdef DEBUG
00485 trace_pixel_ptr = 0;
00486 if (vpc->trace_u >= 0 && vpc->trace_v >= 0) {
00487 #ifdef GRAYSCALE
00488 trace_pixel_ptr = &vpc->int_image.gray_intim[vpc->trace_u +
00489 vpc->trace_v*vpc->intermediate_width];
00490 #endif
00491 #ifdef RGB
00492 trace_pixel_ptr = &vpc->int_image.rgb_intim[vpc->trace_u +
00493 vpc->trace_v*vpc->intermediate_width];
00494 #endif
00495 #ifdef COMPUTE_SHADOW_BUFFER
00496 slice_u_int = (int)ceil(vpc->shear_i * vpc->trace_shadow_k +
00497 vpc->trans_i) - 1;
00498 shadow_slice_u_int = (int)ceil(vpc->shadow_shear_i *
00499 vpc->trace_shadow_k + vpc->shadow_trans_i) - 1;
00500 slice_v_int = (int)ceil(vpc->shear_j * vpc->trace_shadow_k
00501 + vpc->trans_j) - 1;
00502 shadow_slice_v_int = (int)ceil(vpc->shadow_shear_j *
00503 vpc->trace_shadow_k + vpc->shadow_trans_j) - 1;
00504 trace_pixel_ptr = &vpc->shadow_buffer[vpc->trace_u +
00505 shadow_slice_u_int - slice_u_int +
00506 (vpc->trace_v + shadow_slice_v_int -
00507 slice_v_int)*vpc->shadow_width];
00508 #endif
00509 }
00510 #endif
00511
00512
00513
00514
00515
00516 for (j = 0; j <= jcount; j++) {
00517
00518
00519
00520
00521
00522 i = icount;
00523 CLEAR_VOXELS_LOADED;
00524 last_run_state = ALL_ZERO;
00525
00526 #ifdef RAWVOLUME
00527 botRLEdata = (char *)voxel_data + j*voxel_jstride;
00528 topRLEdata = botRLEdata - voxel_jstride;
00529 if (!use_octree) {
00530 if (j == 0) {
00531 run_state = BOT_NONZERO;
00532 toprun_count = icount+2;
00533 botrun_count = icount;
00534 } else if (j == jcount) {
00535 run_state = TOP_NONZERO;
00536 toprun_count = icount;
00537 botrun_count = icount+2;
00538 } else {
00539 run_state = ALL_NONZERO;
00540 toprun_count = icount;
00541 botrun_count = icount;
00542 }
00543 } else
00544 #endif
00545 if (j == 0) {
00546 run_state = BOT_NONZERO;
00547 toprun_count = icount+2;
00548 botrun_count = 0;
00549 } else if (j == jcount) {
00550 run_state = TOP_NONZERO;
00551 toprun_count = 0;
00552 botrun_count = icount+2;
00553 } else {
00554 run_state = ALL_NONZERO;
00555 toprun_count = 0;
00556 botrun_count = 0;
00557 }
00558
00559 #ifdef INDEX_VOLUME
00560 scanline_topRLElen = topRLElen;
00561 scanline_botRLElen = botRLElen;
00562 scanline_topRLEdata = topRLEdata;
00563 scanline_botRLEdata = botRLEdata;
00564 if (j == 0) {
00565 top_voxel_index = voxel_index;
00566 bot_voxel_index = voxel_index;
00567 } else {
00568 top_voxel_index = bot_voxel_index;
00569 bot_voxel_index += icount;
00570 }
00571 #endif
00572
00573
00574
00575
00576
00577
00578 #ifdef RAWVOLUME
00579 if (use_octree) {
00580 top_len_base = bot_len_base;
00581 if (scans_left == 0) {
00582 if (bot_len_base == runlen_buf1)
00583 bot_len_base = runlen_buf2;
00584 else
00585 bot_len_base = runlen_buf1;
00586
00587 GET_HIRES_TIME(vpc, t1);
00588 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
00589 COPY_HIRES_TIME(t0, t1);
00590
00591 scans_left = VPComputeScanRuns(vpc, level_stack, bot_len_base,
00592 best_view_axis, j, icount);
00593
00594 GET_HIRES_TIME(vpc, t1);
00595 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_OCTREE, t0, t1);
00596 COPY_HIRES_TIME(t0, t1);
00597 }
00598 #ifdef DEBUG
00599 if (j > 0)
00600 VPCheckRuns(vpc, top_len_base, best_view_axis, k, j-1);
00601 if (j < jcount)
00602 VPCheckRuns(vpc, bot_len_base, best_view_axis, k, j);
00603 #endif
00604 scans_left--;
00605 topRLElen = top_len_base;
00606 botRLElen = bot_len_base;
00607 }
00608 #endif
00609
00610
00611
00612
00613
00614 Debug((vpc, VPDEBUG_COMPOSITE, "StartIScan(u=%d,v=%d)\n",
00615 (((int)ipixel - (int)vpc->int_image.gray_intim) /
00616 sizeof(GrayIntPixel)) % vpc->intermediate_width,
00617 (((int)ipixel - (int)vpc->int_image.gray_intim) /
00618 sizeof(GrayIntPixel)) / vpc->intermediate_width));
00619
00620 #ifdef UNROLL_RUN_LOOP
00621 while (i > 0) {
00622 #else
00623 while (i >= 0) {
00624 #endif
00625
00626
00627
00628
00629 if (last_run_state == ALL_ZERO) {
00630 #ifndef UNROLL_RUN_LOOP
00631 if (i == 0) {
00632 Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
00633 ipixel += 1; shadow_pixel += 1;
00634 final_run_state = ALL_ZERO;
00635 i = -1;
00636 break;
00637 }
00638 #endif
00639
00640
00641 while (toprun_count == 0) {
00642 toprun_count = *topRLElen++;
00643 run_state ^= 1;
00644 }
00645 while (botrun_count == 0) {
00646 botrun_count = *botRLElen++;
00647 run_state ^= 2;
00648 }
00649 if (run_state == ALL_ZERO) {
00650 COUNT_SPECIAL_ZERO_SKIP;
00651
00652
00653 count = MIN(toprun_count, botrun_count);
00654 toprun_count -= count;
00655 botrun_count -= count;
00656 ipixel += count; shadow_pixel += count;
00657 topRLEdata += count * voxel_istride;
00658 botRLEdata += count * voxel_istride;
00659 i -= count;
00660 ASSERT(i >= 0);
00661 Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(%d)\n", count));
00662 continue;
00663 }
00664 }
00665
00666 #ifndef SKIP_ERT
00667
00668
00669
00670
00671 if ((ert_skip_count = ipixel->lnk) != 0) {
00672
00673 GET_HIRES_TIME(vpc, t1);
00674 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
00675 COPY_HIRES_TIME(t0, t1);
00676
00677 COUNT_ERT_SKIP;
00678
00679 #ifndef UNROLL_RUN_LOOP
00680 if (i == 0) {
00681 ipixel += 1; shadow_pixel += 1;
00682 final_run_state = last_run_state;
00683 i = -1;
00684 Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
00685 break;
00686 }
00687 #endif
00688
00689
00690 if (ert_skip_count < i &&
00691 (count = ipixel[ert_skip_count].lnk) != 0) {
00692
00693 do {
00694 COUNT_ERT_SKIP_AGAIN;
00695 ert_skip_count += count;
00696 } while (ert_skip_count < i &&
00697 (count = ipixel[ert_skip_count].lnk) != 0);
00698
00699
00700
00701
00702
00703
00704 ipixel2 = ipixel;
00705 update_interval = 1;
00706 count = ert_skip_count - 1;
00707 while (count > 0) {
00708 COUNT_ERT_UPDATE;
00709 ipixel2 += update_interval;
00710 if (count > 255)
00711 ipixel2->lnk = 255;
00712 else
00713 ipixel2->lnk = count;
00714 update_interval *= 2;
00715 count -= update_interval;
00716 }
00717
00718
00719 COUNT_ERT_UPDATE;
00720 if (ert_skip_count > 255)
00721 ert_skip_count = 255;
00722 ipixel->lnk = ert_skip_count;
00723 }
00724
00725
00726 if (ert_skip_count > i)
00727 ert_skip_count = i;
00728 Debug((vpc, VPDEBUG_COMPOSITE,"ERTSkip(%d)\n",ert_skip_count));
00729 ipixel += ert_skip_count; shadow_pixel += ert_skip_count;
00730 CLEAR_VOXELS_LOADED;
00731
00732 #ifdef INDEX_VOLUME
00733
00734 next_i = icount - i + ert_skip_count;
00735 if (next_i == icount) {
00736 next_i--;
00737 next_scan = 1;
00738 } else {
00739 next_scan = 0;
00740 }
00741
00742
00743 vindex = &top_voxel_index[next_i];
00744 toprun_count = vindex->run_count;
00745 topRLElen = scanline_topRLElen + vindex->len_offset;
00746 if (vindex->data_offset & INDEX_RUN_IS_ZERO) {
00747 run_state &= ~1;
00748 topRLEdata = scanline_topRLEdata +
00749 (vindex->data_offset & ~INDEX_RUN_IS_ZERO);
00750 } else {
00751 run_state |= 1;
00752 topRLEdata = scanline_topRLEdata + vindex->data_offset;
00753 }
00754
00755
00756 vindex = &bot_voxel_index[next_i];
00757 botrun_count = vindex->run_count;
00758 botRLElen = scanline_botRLElen + vindex->len_offset;
00759 if (vindex->data_offset & INDEX_RUN_IS_ZERO) {
00760 run_state &= ~2;
00761 botRLEdata = scanline_botRLEdata +
00762 (vindex->data_offset & ~INDEX_RUN_IS_ZERO);
00763 } else {
00764 run_state |= 2;
00765 botRLEdata = scanline_botRLEdata + vindex->data_offset;
00766 }
00767
00768
00769 if (next_scan) {
00770
00771 while (toprun_count == 0) {
00772 toprun_count = *topRLElen++;
00773 run_state ^= 1;
00774 }
00775 toprun_count--;
00776 if (run_state & 1) {
00777 topRLEdata += 1 * voxel_istride;
00778 } else {
00779 topRLEdata += 1 * voxel_istride;
00780 }
00781
00782
00783 while (botrun_count == 0) {
00784 botrun_count = *botRLElen++;
00785 run_state ^= 2;
00786 }
00787 botrun_count--;
00788 if (run_state & 2) {
00789 botRLEdata += 1 * voxel_istride;
00790 } else {
00791 botRLEdata += 1 * voxel_istride;
00792 }
00793 }
00794
00795 #else
00796
00797 count = ert_skip_count;
00798 for (;;) {
00799 if (toprun_count >= count) {
00800 toprun_count -= count;
00801 if (run_state & 1) {
00802 topRLEdata += count * voxel_istride;
00803 } else {
00804 topRLEdata += count * voxel_istride;
00805 }
00806 break;
00807 } else {
00808 count -= toprun_count;
00809 if (run_state & 1) {
00810 topRLEdata += toprun_count * voxel_istride;
00811 } else {
00812 topRLEdata += toprun_count * voxel_istride;
00813 }
00814 toprun_count = *topRLElen++;
00815 if (toprun_count == 0)
00816 toprun_count = *topRLElen++;
00817 else
00818 run_state ^= 1;
00819 }
00820 }
00821
00822
00823 count = ert_skip_count;
00824 for (;;) {
00825 if (botrun_count >= count) {
00826 botrun_count -= count;
00827 if (run_state & 2) {
00828 botRLEdata += count * voxel_istride;
00829 } else {
00830 botRLEdata += count * voxel_istride;
00831 }
00832 break;
00833 } else {
00834 count -= botrun_count;
00835 if (run_state & 2) {
00836 botRLEdata += botrun_count * voxel_istride;
00837 } else {
00838 botRLEdata += botrun_count * voxel_istride;
00839 }
00840 botrun_count = *botRLElen++;
00841 if (botrun_count == 0)
00842 botrun_count = *botRLElen++;
00843 else
00844 run_state ^= 2;
00845 }
00846 }
00847 #endif
00848 i -= ert_skip_count;
00849 last_run_state = run_state;
00850 if (i == 0) {
00851 #ifdef UNROLL_RUN_LOOP
00852 break;
00853 #else
00854 if (last_run_state == ALL_ZERO) {
00855 ipixel += 1; shadow_pixel += 1;
00856 final_run_state = ALL_ZERO;
00857 i = -1;
00858 Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
00859 break;
00860 }
00861 if (ipixel->lnk != 0) {
00862 ipixel += 1; shadow_pixel += 1;
00863 final_run_state = last_run_state;
00864 i = -1;
00865 Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
00866 break;
00867 }
00868 #endif
00869 }
00870
00871 GET_HIRES_TIME(vpc, t1);
00872 STORE_HIRES_TIME(vpc, VPTIMER_ERT, t0, t1);
00873 COPY_HIRES_TIME(t0, t1);
00874 }
00875 ASSERT(ipixel->opcflt < max_opacity);
00876 #endif
00877
00878
00879
00880
00881
00882 #ifndef UNROLL_RUN_LOOP
00883 if (i == 0) {
00884 final_run_state = last_run_state;
00885 run_state = ALL_ZERO;
00886 i = -1;
00887 count = 1;
00888 Debug((vpc, VPDEBUG_COMPOSITE, "Run(1)End\n"));
00889 } else {
00890 #endif
00891
00892 while (toprun_count == 0) {
00893 toprun_count = *topRLElen++;
00894 run_state ^= 1;
00895 }
00896 while (botrun_count == 0) {
00897 botrun_count = *botRLElen++;
00898 run_state ^= 2;
00899 }
00900
00901
00902 count = MIN(toprun_count, botrun_count);
00903 toprun_count -= count;
00904 botrun_count -= count;
00905 i -= count;
00906 Debug((vpc, VPDEBUG_COMPOSITE, "Run(%d)\n", count));
00907 ASSERT(i >= 0);
00908 #ifndef UNROLL_RUN_LOOP
00909 }
00910 #endif
00911 COUNT_RUN_FRAGMENT;
00912
00913
00914
00915
00916
00917 GET_HIRES_TIME(vpc, t1);
00918 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
00919 COPY_HIRES_TIME(t0, t1);
00920
00921 #ifdef SKIP_COMPOSITE
00922 switch (run_state) {
00923 case ALL_ZERO:
00924 ipixel += count; shadow_pixel += count;
00925 topRLEdata += count * voxel_istride;
00926 botRLEdata += count * voxel_istride;
00927 count = 0;
00928 break;
00929 case TOP_NONZERO:
00930 ipixel += count; shadow_pixel += count;
00931 topRLEdata += count * voxel_istride;
00932 botRLEdata += count * voxel_istride;
00933 count = 0;
00934 break;
00935 case BOT_NONZERO:
00936 ipixel += count; shadow_pixel += count;
00937 topRLEdata += count * voxel_istride;
00938 botRLEdata += count * voxel_istride;
00939 count = 0;
00940 break;
00941 case ALL_NONZERO:
00942 ipixel += count; shadow_pixel += count;
00943 topRLEdata += count * voxel_istride;
00944 botRLEdata += count * voxel_istride;
00945 count = 0;
00946 break;
00947 }
00948 #else
00949 #ifdef UNROLL_RUN_LOOP
00950
00951 switch ((last_run_state << 2) | run_state) {
00952 case ALL_ZERO__ALL_ZERO:
00953
00954 ipixel += count; shadow_pixel += count;
00955 topRLEdata += count * voxel_istride;
00956 botRLEdata += count * voxel_istride;
00957 count = 0;
00958 break;
00959 case TOP_NONZERO__ALL_ZERO:
00960
00961
00962 if (!voxels_loaded) {
00963
00964
00965 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
00966 opacity = param0_table[opac_param];
00967 if (param1_size != 0) {
00968 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
00969 opacity *= param1_table[opac_param];
00970 if (param2_size != 0) {
00971 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
00972 opacity *= param2_table[opac_param];
00973 }
00974 }
00975 if (opacity > min_opacity) {
00976 opacity_int = opacity*255.;
00977 top_opc = opac_correct[opacity_int];
00978 } else {
00979 top_opc = (float)0.;
00980 };
00981
00982
00983 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
00984 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
00985
00986
00987
00988 top_clr =
00989 shade_table[shade_index + 1*0 + 0] *
00990 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
00991
00992 top_sclr =
00993 shadow_table[shade_index + 1*0 + 0] *
00994 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
00995 for (m = 1; m < num_materials; m++) {
00996
00997
00998 top_clr +=
00999 shade_table[shade_index + 1*m + 0] *
01000 weight_table[weight_index + m];
01001
01002 top_sclr +=
01003 shadow_table[shade_index + 1*m + 0] *
01004 weight_table[weight_index + m];
01005 };
01006 shade_factor = top_opc * slice_depth_cueing;
01007
01008 top_clr *= shade_factor;
01009
01010 top_sclr *= shade_factor;
01011 }
01012
01013 #ifdef DEBUG
01014 if (ipixel == trace_pixel_ptr) {
01015 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01016 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01017 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01018 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01019 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01020 }
01021 #endif
01022 ;
01023
01024 acc_opc = top_opc * wgtTL;
01025 acc_clr = (top_clr + top_sclr *
01026 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
01027
01028 #ifdef DEBUG
01029 if (ipixel == trace_pixel_ptr) {
01030 trace_opcTL = top_opc;
01031 trace_rclrTL = top_clr;
01032 trace_rsclrTL = top_sclr;
01033 }
01034 #endif
01035 ;
01036
01037 COUNT_RESAMPLE;
01038 if (acc_opc > min_opacity) {
01039 COUNT_COMPOSITE;
01040 iopc = ipixel->opcflt;
01041 # ifndef SKIP_ERT
01042 ASSERT(iopc < max_opacity);
01043 # endif
01044 iopc_inv = (float)1. - iopc;
01045 ipixel->clrflt += acc_clr * iopc_inv;
01046 iopc += acc_opc * iopc_inv;
01047 ipixel->opcflt = iopc;
01048
01049 #ifdef DEBUG
01050 if (ipixel == trace_pixel_ptr) {
01051 #ifdef COMPUTE_SHADOW_BUFFER
01052 printf("{%3d} %3d %3d", k, icount-i-count, j);
01053 #else
01054 printf("[%3d] %3d %3d", k, icount-i-count, j);
01055 #endif
01056 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01057 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01058 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01059 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01060 printf(" %3.0f %3.0f\n", iopc*255.,
01061 ipixel->clrflt);
01062
01063 printf(" ");
01064 printf(" %3.0f ",trace_rsclrTL);
01065 printf(" %3.0f ",trace_rsclrBL);
01066 printf(" %3.0f ",trace_rsclrTR);
01067 printf(" %3.0f ",trace_rsclrBR);
01068 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
01069
01070 }
01071 #endif
01072 ;
01073 # ifndef SKIP_ERT
01074 if (iopc >= max_opacity) {
01075 ASSERT(ipixel->lnk == 0);
01076 ipixel->lnk = 1;
01077 }
01078 # endif
01079 };
01080 ipixel += count; shadow_pixel += count;
01081 topRLEdata += count * voxel_istride;
01082 botRLEdata += count * voxel_istride;
01083 count = 0;
01084 break;
01085 case BOT_NONZERO__ALL_ZERO:
01086
01087
01088 if (!voxels_loaded) {
01089
01090
01091 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01092 opacity = param0_table[opac_param];
01093 if (param1_size != 0) {
01094 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01095 opacity *= param1_table[opac_param];
01096 if (param2_size != 0) {
01097 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01098 opacity *= param2_table[opac_param];
01099 }
01100 }
01101 if (opacity > min_opacity) {
01102 opacity_int = opacity*255.;
01103 bot_opc = opac_correct[opacity_int];
01104 } else {
01105 bot_opc = (float)0.;
01106 };
01107
01108
01109 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
01110 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
01111
01112
01113
01114 bot_clr =
01115 shade_table[shade_index + 1*0 + 0] *
01116 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01117
01118 bot_sclr =
01119 shadow_table[shade_index + 1*0 + 0] *
01120 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01121 for (m = 1; m < num_materials; m++) {
01122
01123
01124 bot_clr +=
01125 shade_table[shade_index + 1*m + 0] *
01126 weight_table[weight_index + m];
01127
01128 bot_sclr +=
01129 shadow_table[shade_index + 1*m + 0] *
01130 weight_table[weight_index + m];
01131 };
01132 shade_factor = bot_opc * slice_depth_cueing;
01133
01134 bot_clr *= shade_factor;
01135
01136 bot_sclr *= shade_factor;
01137 }
01138
01139 #ifdef DEBUG
01140 if (ipixel == trace_pixel_ptr) {
01141 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01142 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01143 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01144 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01145 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01146 }
01147 #endif
01148 ;
01149
01150 acc_opc = bot_opc * wgtBL;
01151 acc_clr = (bot_clr + bot_sclr *
01152 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
01153
01154 #ifdef DEBUG
01155 if (ipixel == trace_pixel_ptr) {
01156 trace_opcBL = bot_opc;
01157 trace_rclrBL = bot_clr;
01158 trace_rsclrBL = bot_sclr;
01159 }
01160 #endif
01161 ;
01162
01163 COUNT_RESAMPLE;
01164 if (acc_opc > min_opacity) {
01165 COUNT_COMPOSITE;
01166 iopc = ipixel->opcflt;
01167 # ifndef SKIP_ERT
01168 ASSERT(iopc < max_opacity);
01169 # endif
01170 iopc_inv = (float)1. - iopc;
01171 ipixel->clrflt += acc_clr * iopc_inv;
01172 iopc += acc_opc * iopc_inv;
01173 ipixel->opcflt = iopc;
01174
01175 #ifdef DEBUG
01176 if (ipixel == trace_pixel_ptr) {
01177 #ifdef COMPUTE_SHADOW_BUFFER
01178 printf("{%3d} %3d %3d", k, icount-i-count, j);
01179 #else
01180 printf("[%3d] %3d %3d", k, icount-i-count, j);
01181 #endif
01182 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01183 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01184 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01185 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01186 printf(" %3.0f %3.0f\n", iopc*255.,
01187 ipixel->clrflt);
01188
01189 printf(" ");
01190 printf(" %3.0f ",trace_rsclrTL);
01191 printf(" %3.0f ",trace_rsclrBL);
01192 printf(" %3.0f ",trace_rsclrTR);
01193 printf(" %3.0f ",trace_rsclrBR);
01194 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
01195
01196 }
01197 #endif
01198 ;
01199 # ifndef SKIP_ERT
01200 if (iopc >= max_opacity) {
01201 ASSERT(ipixel->lnk == 0);
01202 ipixel->lnk = 1;
01203 }
01204 # endif
01205 };
01206 ipixel += count; shadow_pixel += count;
01207 topRLEdata += count * voxel_istride;
01208 botRLEdata += count * voxel_istride;
01209 count = 0;
01210 break;
01211 case ALL_NONZERO__ALL_ZERO:
01212
01213
01214 if (!voxels_loaded) {
01215
01216
01217 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01218 opacity = param0_table[opac_param];
01219 if (param1_size != 0) {
01220 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01221 opacity *= param1_table[opac_param];
01222 if (param2_size != 0) {
01223 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01224 opacity *= param2_table[opac_param];
01225 }
01226 }
01227 if (opacity > min_opacity) {
01228 opacity_int = opacity*255.;
01229 top_opc = opac_correct[opacity_int];
01230 } else {
01231 top_opc = (float)0.;
01232 };
01233
01234
01235 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
01236 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
01237
01238
01239
01240 top_clr =
01241 shade_table[shade_index + 1*0 + 0] *
01242 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01243
01244 top_sclr =
01245 shadow_table[shade_index + 1*0 + 0] *
01246 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01247 for (m = 1; m < num_materials; m++) {
01248
01249
01250 top_clr +=
01251 shade_table[shade_index + 1*m + 0] *
01252 weight_table[weight_index + m];
01253
01254 top_sclr +=
01255 shadow_table[shade_index + 1*m + 0] *
01256 weight_table[weight_index + m];
01257 };
01258 shade_factor = top_opc * slice_depth_cueing;
01259
01260 top_clr *= shade_factor;
01261
01262 top_sclr *= shade_factor;
01263
01264
01265 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01266 opacity = param0_table[opac_param];
01267 if (param1_size != 0) {
01268 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01269 opacity *= param1_table[opac_param];
01270 if (param2_size != 0) {
01271 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01272 opacity *= param2_table[opac_param];
01273 }
01274 }
01275 if (opacity > min_opacity) {
01276 opacity_int = opacity*255.;
01277 bot_opc = opac_correct[opacity_int];
01278 } else {
01279 bot_opc = (float)0.;
01280 };
01281
01282
01283 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
01284 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
01285
01286
01287
01288 bot_clr =
01289 shade_table[shade_index + 1*0 + 0] *
01290 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01291
01292 bot_sclr =
01293 shadow_table[shade_index + 1*0 + 0] *
01294 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01295 for (m = 1; m < num_materials; m++) {
01296
01297
01298 bot_clr +=
01299 shade_table[shade_index + 1*m + 0] *
01300 weight_table[weight_index + m];
01301
01302 bot_sclr +=
01303 shadow_table[shade_index + 1*m + 0] *
01304 weight_table[weight_index + m];
01305 };
01306 shade_factor = bot_opc * slice_depth_cueing;
01307
01308 bot_clr *= shade_factor;
01309
01310 bot_sclr *= shade_factor;
01311 }
01312
01313 #ifdef DEBUG
01314 if (ipixel == trace_pixel_ptr) {
01315 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01316 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01317 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01318 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01319 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01320 }
01321 #endif
01322 ;
01323
01324 acc_opc = top_opc * wgtTL;
01325 acc_clr = (top_clr + top_sclr *
01326 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
01327
01328 #ifdef DEBUG
01329 if (ipixel == trace_pixel_ptr) {
01330 trace_opcTL = top_opc;
01331 trace_rclrTL = top_clr;
01332 trace_rsclrTL = top_sclr;
01333 }
01334 #endif
01335 ;
01336
01337 acc_opc += bot_opc * wgtBL;
01338 acc_clr += (bot_clr + bot_sclr *
01339 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
01340
01341 #ifdef DEBUG
01342 if (ipixel == trace_pixel_ptr) {
01343 trace_opcBL = bot_opc;
01344 trace_rclrBL = bot_clr;
01345 trace_rsclrBL = bot_sclr;
01346 }
01347 #endif
01348 ;
01349
01350 COUNT_RESAMPLE;
01351 if (acc_opc > min_opacity) {
01352 COUNT_COMPOSITE;
01353 iopc = ipixel->opcflt;
01354 # ifndef SKIP_ERT
01355 ASSERT(iopc < max_opacity);
01356 # endif
01357 iopc_inv = (float)1. - iopc;
01358 ipixel->clrflt += acc_clr * iopc_inv;
01359 iopc += acc_opc * iopc_inv;
01360 ipixel->opcflt = iopc;
01361
01362 #ifdef DEBUG
01363 if (ipixel == trace_pixel_ptr) {
01364 #ifdef COMPUTE_SHADOW_BUFFER
01365 printf("{%3d} %3d %3d", k, icount-i-count, j);
01366 #else
01367 printf("[%3d] %3d %3d", k, icount-i-count, j);
01368 #endif
01369 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01370 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01371 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01372 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01373 printf(" %3.0f %3.0f\n", iopc*255.,
01374 ipixel->clrflt);
01375
01376 printf(" ");
01377 printf(" %3.0f ",trace_rsclrTL);
01378 printf(" %3.0f ",trace_rsclrBL);
01379 printf(" %3.0f ",trace_rsclrTR);
01380 printf(" %3.0f ",trace_rsclrBR);
01381 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
01382
01383 }
01384 #endif
01385 ;
01386 # ifndef SKIP_ERT
01387 if (iopc >= max_opacity) {
01388 ASSERT(ipixel->lnk == 0);
01389 ipixel->lnk = 1;
01390 }
01391 # endif
01392 };
01393 ipixel += count; shadow_pixel += count;
01394 topRLEdata += count * voxel_istride;
01395 botRLEdata += count * voxel_istride;
01396 count = 0;
01397 break;
01398 case ALL_ZERO__TOP_NONZERO:
01399
01400
01401
01402 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01403 opacity = param0_table[opac_param];
01404 if (param1_size != 0) {
01405 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01406 opacity *= param1_table[opac_param];
01407 if (param2_size != 0) {
01408 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01409 opacity *= param2_table[opac_param];
01410 }
01411 }
01412 if (opacity > min_opacity) {
01413 opacity_int = opacity*255.;
01414 top_opc = opac_correct[opacity_int];
01415 } else {
01416 top_opc = (float)0.;
01417 };
01418
01419
01420 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
01421 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
01422
01423
01424
01425 top_clr =
01426 shade_table[shade_index + 1*0 + 0] *
01427 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01428
01429 top_sclr =
01430 shadow_table[shade_index + 1*0 + 0] *
01431 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01432 for (m = 1; m < num_materials; m++) {
01433
01434
01435 top_clr +=
01436 shade_table[shade_index + 1*m + 0] *
01437 weight_table[weight_index + m];
01438
01439 top_sclr +=
01440 shadow_table[shade_index + 1*m + 0] *
01441 weight_table[weight_index + m];
01442 };
01443 shade_factor = top_opc * slice_depth_cueing;
01444
01445 top_clr *= shade_factor;
01446
01447 top_sclr *= shade_factor;
01448
01449 #ifdef DEBUG
01450 if (ipixel == trace_pixel_ptr) {
01451 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01452 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01453 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01454 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01455 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01456 }
01457 #endif
01458 ;
01459
01460 acc_opc = top_opc * wgtTR;
01461 acc_clr = (top_clr + top_sclr *
01462 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
01463
01464 #ifdef DEBUG
01465 if (ipixel == trace_pixel_ptr) {
01466 trace_opcTR = top_opc;
01467 trace_rclrTR = top_clr;
01468 trace_rsclrTR = top_sclr;
01469 }
01470 #endif
01471 ;
01472
01473 COUNT_RESAMPLE;
01474 if (acc_opc > min_opacity) {
01475 COUNT_COMPOSITE;
01476 iopc = ipixel->opcflt;
01477 # ifndef SKIP_ERT
01478 ASSERT(iopc < max_opacity);
01479 # endif
01480 iopc_inv = (float)1. - iopc;
01481 ipixel->clrflt += acc_clr * iopc_inv;
01482 iopc += acc_opc * iopc_inv;
01483 ipixel->opcflt = iopc;
01484
01485 #ifdef DEBUG
01486 if (ipixel == trace_pixel_ptr) {
01487 #ifdef COMPUTE_SHADOW_BUFFER
01488 printf("{%3d} %3d %3d", k, icount-i-count, j);
01489 #else
01490 printf("[%3d] %3d %3d", k, icount-i-count, j);
01491 #endif
01492 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01493 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01494 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01495 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01496 printf(" %3.0f %3.0f\n", iopc*255.,
01497 ipixel->clrflt);
01498
01499 printf(" ");
01500 printf(" %3.0f ",trace_rsclrTL);
01501 printf(" %3.0f ",trace_rsclrBL);
01502 printf(" %3.0f ",trace_rsclrTR);
01503 printf(" %3.0f ",trace_rsclrBR);
01504 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
01505
01506 }
01507 #endif
01508 ;
01509 # ifndef SKIP_ERT
01510 if (iopc >= max_opacity) {
01511 ASSERT(ipixel->lnk == 0);
01512 ipixel->lnk = 1;
01513 }
01514 # endif
01515 };
01516 ipixel += 1; shadow_pixel += 1;
01517 topRLEdata += 1 * voxel_istride;
01518 botRLEdata += 1 * voxel_istride;
01519 count--;
01520 SET_VOXELS_LOADED;
01521
01522
01523
01524 while (count > 0) {
01525 if (PIXEL_IS_OPAQUE(ipixel))
01526 break;
01527 if (!voxels_loaded) {
01528
01529
01530 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01531 opacity = param0_table[opac_param];
01532 if (param1_size != 0) {
01533 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01534 opacity *= param1_table[opac_param];
01535 if (param2_size != 0) {
01536 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01537 opacity *= param2_table[opac_param];
01538 }
01539 }
01540 if (opacity > min_opacity) {
01541 opacity_int = opacity*255.;
01542 top_opc = opac_correct[opacity_int];
01543 } else {
01544 top_opc = (float)0.;
01545 };
01546
01547
01548 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
01549 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
01550
01551
01552
01553 top_clr =
01554 shade_table[shade_index + 1*0 + 0] *
01555 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01556
01557 top_sclr =
01558 shadow_table[shade_index + 1*0 + 0] *
01559 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01560 for (m = 1; m < num_materials; m++) {
01561
01562
01563 top_clr +=
01564 shade_table[shade_index + 1*m + 0] *
01565 weight_table[weight_index + m];
01566
01567 top_sclr +=
01568 shadow_table[shade_index + 1*m + 0] *
01569 weight_table[weight_index + m];
01570 };
01571 shade_factor = top_opc * slice_depth_cueing;
01572
01573 top_clr *= shade_factor;
01574
01575 top_sclr *= shade_factor;
01576 }
01577
01578 #ifdef DEBUG
01579 if (ipixel == trace_pixel_ptr) {
01580 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01581 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01582 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01583 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01584 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01585 }
01586 #endif
01587 ;
01588
01589 acc_opc = top_opc * wgtTL;
01590 acc_clr = (top_clr + top_sclr *
01591 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
01592
01593 #ifdef DEBUG
01594 if (ipixel == trace_pixel_ptr) {
01595 trace_opcTL = top_opc;
01596 trace_rclrTL = top_clr;
01597 trace_rsclrTL = top_sclr;
01598 }
01599 #endif
01600 ;
01601
01602
01603 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01604 opacity = param0_table[opac_param];
01605 if (param1_size != 0) {
01606 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01607 opacity *= param1_table[opac_param];
01608 if (param2_size != 0) {
01609 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01610 opacity *= param2_table[opac_param];
01611 }
01612 }
01613 if (opacity > min_opacity) {
01614 opacity_int = opacity*255.;
01615 top_opc = opac_correct[opacity_int];
01616 } else {
01617 top_opc = (float)0.;
01618 };
01619
01620
01621 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
01622 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
01623
01624
01625
01626 top_clr =
01627 shade_table[shade_index + 1*0 + 0] *
01628 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01629
01630 top_sclr =
01631 shadow_table[shade_index + 1*0 + 0] *
01632 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01633 for (m = 1; m < num_materials; m++) {
01634
01635
01636 top_clr +=
01637 shade_table[shade_index + 1*m + 0] *
01638 weight_table[weight_index + m];
01639
01640 top_sclr +=
01641 shadow_table[shade_index + 1*m + 0] *
01642 weight_table[weight_index + m];
01643 };
01644 shade_factor = top_opc * slice_depth_cueing;
01645
01646 top_clr *= shade_factor;
01647
01648 top_sclr *= shade_factor;
01649
01650 acc_opc += top_opc * wgtTR;
01651 acc_clr += (top_clr + top_sclr *
01652 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
01653
01654 #ifdef DEBUG
01655 if (ipixel == trace_pixel_ptr) {
01656 trace_opcTR = top_opc;
01657 trace_rclrTR = top_clr;
01658 trace_rsclrTR = top_sclr;
01659 }
01660 #endif
01661 ;
01662
01663 COUNT_RESAMPLE;
01664 if (acc_opc > min_opacity) {
01665 COUNT_COMPOSITE;
01666 iopc = ipixel->opcflt;
01667 # ifndef SKIP_ERT
01668 ASSERT(iopc < max_opacity);
01669 # endif
01670 iopc_inv = (float)1. - iopc;
01671 ipixel->clrflt += acc_clr * iopc_inv;
01672 iopc += acc_opc * iopc_inv;
01673 ipixel->opcflt = iopc;
01674
01675 #ifdef DEBUG
01676 if (ipixel == trace_pixel_ptr) {
01677 #ifdef COMPUTE_SHADOW_BUFFER
01678 printf("{%3d} %3d %3d", k, icount-i-count, j);
01679 #else
01680 printf("[%3d] %3d %3d", k, icount-i-count, j);
01681 #endif
01682 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01683 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01684 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01685 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01686 printf(" %3.0f %3.0f\n", iopc*255.,
01687 ipixel->clrflt);
01688
01689 printf(" ");
01690 printf(" %3.0f ",trace_rsclrTL);
01691 printf(" %3.0f ",trace_rsclrBL);
01692 printf(" %3.0f ",trace_rsclrTR);
01693 printf(" %3.0f ",trace_rsclrBR);
01694 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
01695
01696 }
01697 #endif
01698 ;
01699 # ifndef SKIP_ERT
01700 if (iopc >= max_opacity) {
01701 ASSERT(ipixel->lnk == 0);
01702 ipixel->lnk = 1;
01703 }
01704 # endif
01705 };
01706 ipixel += 1; shadow_pixel += 1;
01707 topRLEdata += 1 * voxel_istride;
01708 botRLEdata += 1 * voxel_istride;
01709 count--;
01710 SET_VOXELS_LOADED;
01711 }
01712 break;
01713 case TOP_NONZERO__TOP_NONZERO:
01714
01715
01716 while (count > 0) {
01717 if (PIXEL_IS_OPAQUE(ipixel))
01718 break;
01719 if (!voxels_loaded) {
01720
01721
01722 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
01723 opacity = param0_table[opac_param];
01724 if (param1_size != 0) {
01725 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
01726 opacity *= param1_table[opac_param];
01727 if (param2_size != 0) {
01728 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
01729 opacity *= param2_table[opac_param];
01730 }
01731 }
01732 if (opacity > min_opacity) {
01733 opacity_int = opacity*255.;
01734 top_opc = opac_correct[opacity_int];
01735 } else {
01736 top_opc = (float)0.;
01737 };
01738
01739
01740 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
01741 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
01742
01743
01744
01745 top_clr =
01746 shade_table[shade_index + 1*0 + 0] *
01747 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01748
01749 top_sclr =
01750 shadow_table[shade_index + 1*0 + 0] *
01751 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01752 for (m = 1; m < num_materials; m++) {
01753
01754
01755 top_clr +=
01756 shade_table[shade_index + 1*m + 0] *
01757 weight_table[weight_index + m];
01758
01759 top_sclr +=
01760 shadow_table[shade_index + 1*m + 0] *
01761 weight_table[weight_index + m];
01762 };
01763 shade_factor = top_opc * slice_depth_cueing;
01764
01765 top_clr *= shade_factor;
01766
01767 top_sclr *= shade_factor;
01768 }
01769
01770 #ifdef DEBUG
01771 if (ipixel == trace_pixel_ptr) {
01772 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01773 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01774 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01775 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01776 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01777 }
01778 #endif
01779 ;
01780
01781 acc_opc = top_opc * wgtTL;
01782 acc_clr = (top_clr + top_sclr *
01783 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
01784
01785 #ifdef DEBUG
01786 if (ipixel == trace_pixel_ptr) {
01787 trace_opcTL = top_opc;
01788 trace_rclrTL = top_clr;
01789 trace_rsclrTL = top_sclr;
01790 }
01791 #endif
01792 ;
01793
01794
01795 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01796 opacity = param0_table[opac_param];
01797 if (param1_size != 0) {
01798 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01799 opacity *= param1_table[opac_param];
01800 if (param2_size != 0) {
01801 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01802 opacity *= param2_table[opac_param];
01803 }
01804 }
01805 if (opacity > min_opacity) {
01806 opacity_int = opacity*255.;
01807 top_opc = opac_correct[opacity_int];
01808 } else {
01809 top_opc = (float)0.;
01810 };
01811
01812
01813 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
01814 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
01815
01816
01817
01818 top_clr =
01819 shade_table[shade_index + 1*0 + 0] *
01820 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01821
01822 top_sclr =
01823 shadow_table[shade_index + 1*0 + 0] *
01824 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01825 for (m = 1; m < num_materials; m++) {
01826
01827
01828 top_clr +=
01829 shade_table[shade_index + 1*m + 0] *
01830 weight_table[weight_index + m];
01831
01832 top_sclr +=
01833 shadow_table[shade_index + 1*m + 0] *
01834 weight_table[weight_index + m];
01835 };
01836 shade_factor = top_opc * slice_depth_cueing;
01837
01838 top_clr *= shade_factor;
01839
01840 top_sclr *= shade_factor;
01841
01842 acc_opc += top_opc * wgtTR;
01843 acc_clr += (top_clr + top_sclr *
01844 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
01845
01846 #ifdef DEBUG
01847 if (ipixel == trace_pixel_ptr) {
01848 trace_opcTR = top_opc;
01849 trace_rclrTR = top_clr;
01850 trace_rsclrTR = top_sclr;
01851 }
01852 #endif
01853 ;
01854
01855 COUNT_RESAMPLE;
01856 if (acc_opc > min_opacity) {
01857 COUNT_COMPOSITE;
01858 iopc = ipixel->opcflt;
01859 # ifndef SKIP_ERT
01860 ASSERT(iopc < max_opacity);
01861 # endif
01862 iopc_inv = (float)1. - iopc;
01863 ipixel->clrflt += acc_clr * iopc_inv;
01864 iopc += acc_opc * iopc_inv;
01865 ipixel->opcflt = iopc;
01866
01867 #ifdef DEBUG
01868 if (ipixel == trace_pixel_ptr) {
01869 #ifdef COMPUTE_SHADOW_BUFFER
01870 printf("{%3d} %3d %3d", k, icount-i-count, j);
01871 #else
01872 printf("[%3d] %3d %3d", k, icount-i-count, j);
01873 #endif
01874 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
01875 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
01876 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
01877 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
01878 printf(" %3.0f %3.0f\n", iopc*255.,
01879 ipixel->clrflt);
01880
01881 printf(" ");
01882 printf(" %3.0f ",trace_rsclrTL);
01883 printf(" %3.0f ",trace_rsclrBL);
01884 printf(" %3.0f ",trace_rsclrTR);
01885 printf(" %3.0f ",trace_rsclrBR);
01886 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
01887
01888 }
01889 #endif
01890 ;
01891 # ifndef SKIP_ERT
01892 if (iopc >= max_opacity) {
01893 ASSERT(ipixel->lnk == 0);
01894 ipixel->lnk = 1;
01895 }
01896 # endif
01897 };
01898 ipixel += 1; shadow_pixel += 1;
01899 topRLEdata += 1 * voxel_istride;
01900 botRLEdata += 1 * voxel_istride;
01901 count--;
01902 SET_VOXELS_LOADED;
01903 }
01904 break;
01905 case BOT_NONZERO__TOP_NONZERO:
01906
01907
01908 if (!voxels_loaded) {
01909
01910
01911 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
01912 opacity = param0_table[opac_param];
01913 if (param1_size != 0) {
01914 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
01915 opacity *= param1_table[opac_param];
01916 if (param2_size != 0) {
01917 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
01918 opacity *= param2_table[opac_param];
01919 }
01920 }
01921 if (opacity > min_opacity) {
01922 opacity_int = opacity*255.;
01923 bot_opc = opac_correct[opacity_int];
01924 } else {
01925 bot_opc = (float)0.;
01926 };
01927
01928
01929 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
01930 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
01931
01932
01933
01934 bot_clr =
01935 shade_table[shade_index + 1*0 + 0] *
01936 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01937
01938 bot_sclr =
01939 shadow_table[shade_index + 1*0 + 0] *
01940 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
01941 for (m = 1; m < num_materials; m++) {
01942
01943
01944 bot_clr +=
01945 shade_table[shade_index + 1*m + 0] *
01946 weight_table[weight_index + m];
01947
01948 bot_sclr +=
01949 shadow_table[shade_index + 1*m + 0] *
01950 weight_table[weight_index + m];
01951 };
01952 shade_factor = bot_opc * slice_depth_cueing;
01953
01954 bot_clr *= shade_factor;
01955
01956 bot_sclr *= shade_factor;
01957 }
01958
01959 #ifdef DEBUG
01960 if (ipixel == trace_pixel_ptr) {
01961 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
01962 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
01963 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
01964 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
01965 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
01966 }
01967 #endif
01968 ;
01969
01970 acc_opc = bot_opc * wgtBL;
01971 acc_clr = (bot_clr + bot_sclr *
01972 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
01973
01974 #ifdef DEBUG
01975 if (ipixel == trace_pixel_ptr) {
01976 trace_opcBL = bot_opc;
01977 trace_rclrBL = bot_clr;
01978 trace_rsclrBL = bot_sclr;
01979 }
01980 #endif
01981 ;
01982
01983
01984 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
01985 opacity = param0_table[opac_param];
01986 if (param1_size != 0) {
01987 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
01988 opacity *= param1_table[opac_param];
01989 if (param2_size != 0) {
01990 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
01991 opacity *= param2_table[opac_param];
01992 }
01993 }
01994 if (opacity > min_opacity) {
01995 opacity_int = opacity*255.;
01996 top_opc = opac_correct[opacity_int];
01997 } else {
01998 top_opc = (float)0.;
01999 };
02000
02001
02002 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
02003 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
02004
02005
02006
02007 top_clr =
02008 shade_table[shade_index + 1*0 + 0] *
02009 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02010
02011 top_sclr =
02012 shadow_table[shade_index + 1*0 + 0] *
02013 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02014 for (m = 1; m < num_materials; m++) {
02015
02016
02017 top_clr +=
02018 shade_table[shade_index + 1*m + 0] *
02019 weight_table[weight_index + m];
02020
02021 top_sclr +=
02022 shadow_table[shade_index + 1*m + 0] *
02023 weight_table[weight_index + m];
02024 };
02025 shade_factor = top_opc * slice_depth_cueing;
02026
02027 top_clr *= shade_factor;
02028
02029 top_sclr *= shade_factor;
02030
02031 acc_opc += top_opc * wgtTR;
02032 acc_clr += (top_clr + top_sclr *
02033 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
02034
02035 #ifdef DEBUG
02036 if (ipixel == trace_pixel_ptr) {
02037 trace_opcTR = top_opc;
02038 trace_rclrTR = top_clr;
02039 trace_rsclrTR = top_sclr;
02040 }
02041 #endif
02042 ;
02043
02044 COUNT_RESAMPLE;
02045 if (acc_opc > min_opacity) {
02046 COUNT_COMPOSITE;
02047 iopc = ipixel->opcflt;
02048 # ifndef SKIP_ERT
02049 ASSERT(iopc < max_opacity);
02050 # endif
02051 iopc_inv = (float)1. - iopc;
02052 ipixel->clrflt += acc_clr * iopc_inv;
02053 iopc += acc_opc * iopc_inv;
02054 ipixel->opcflt = iopc;
02055
02056 #ifdef DEBUG
02057 if (ipixel == trace_pixel_ptr) {
02058 #ifdef COMPUTE_SHADOW_BUFFER
02059 printf("{%3d} %3d %3d", k, icount-i-count, j);
02060 #else
02061 printf("[%3d] %3d %3d", k, icount-i-count, j);
02062 #endif
02063 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02064 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02065 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02066 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02067 printf(" %3.0f %3.0f\n", iopc*255.,
02068 ipixel->clrflt);
02069
02070 printf(" ");
02071 printf(" %3.0f ",trace_rsclrTL);
02072 printf(" %3.0f ",trace_rsclrBL);
02073 printf(" %3.0f ",trace_rsclrTR);
02074 printf(" %3.0f ",trace_rsclrBR);
02075 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
02076
02077 }
02078 #endif
02079 ;
02080 # ifndef SKIP_ERT
02081 if (iopc >= max_opacity) {
02082 ASSERT(ipixel->lnk == 0);
02083 ipixel->lnk = 1;
02084 }
02085 # endif
02086 };
02087 ipixel += 1; shadow_pixel += 1;
02088 topRLEdata += 1 * voxel_istride;
02089 botRLEdata += 1 * voxel_istride;
02090 count--;
02091 SET_VOXELS_LOADED;
02092
02093
02094
02095 while (count > 0) {
02096 if (PIXEL_IS_OPAQUE(ipixel))
02097 break;
02098 if (!voxels_loaded) {
02099
02100
02101 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02102 opacity = param0_table[opac_param];
02103 if (param1_size != 0) {
02104 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02105 opacity *= param1_table[opac_param];
02106 if (param2_size != 0) {
02107 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02108 opacity *= param2_table[opac_param];
02109 }
02110 }
02111 if (opacity > min_opacity) {
02112 opacity_int = opacity*255.;
02113 top_opc = opac_correct[opacity_int];
02114 } else {
02115 top_opc = (float)0.;
02116 };
02117
02118
02119 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
02120 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
02121
02122
02123
02124 top_clr =
02125 shade_table[shade_index + 1*0 + 0] *
02126 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02127
02128 top_sclr =
02129 shadow_table[shade_index + 1*0 + 0] *
02130 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02131 for (m = 1; m < num_materials; m++) {
02132
02133
02134 top_clr +=
02135 shade_table[shade_index + 1*m + 0] *
02136 weight_table[weight_index + m];
02137
02138 top_sclr +=
02139 shadow_table[shade_index + 1*m + 0] *
02140 weight_table[weight_index + m];
02141 };
02142 shade_factor = top_opc * slice_depth_cueing;
02143
02144 top_clr *= shade_factor;
02145
02146 top_sclr *= shade_factor;
02147 }
02148
02149 #ifdef DEBUG
02150 if (ipixel == trace_pixel_ptr) {
02151 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02152 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02153 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02154 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02155 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02156 }
02157 #endif
02158 ;
02159
02160 acc_opc = top_opc * wgtTL;
02161 acc_clr = (top_clr + top_sclr *
02162 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
02163
02164 #ifdef DEBUG
02165 if (ipixel == trace_pixel_ptr) {
02166 trace_opcTL = top_opc;
02167 trace_rclrTL = top_clr;
02168 trace_rsclrTL = top_sclr;
02169 }
02170 #endif
02171 ;
02172
02173
02174 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
02175 opacity = param0_table[opac_param];
02176 if (param1_size != 0) {
02177 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
02178 opacity *= param1_table[opac_param];
02179 if (param2_size != 0) {
02180 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
02181 opacity *= param2_table[opac_param];
02182 }
02183 }
02184 if (opacity > min_opacity) {
02185 opacity_int = opacity*255.;
02186 top_opc = opac_correct[opacity_int];
02187 } else {
02188 top_opc = (float)0.;
02189 };
02190
02191
02192 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
02193 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
02194
02195
02196
02197 top_clr =
02198 shade_table[shade_index + 1*0 + 0] *
02199 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02200
02201 top_sclr =
02202 shadow_table[shade_index + 1*0 + 0] *
02203 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02204 for (m = 1; m < num_materials; m++) {
02205
02206
02207 top_clr +=
02208 shade_table[shade_index + 1*m + 0] *
02209 weight_table[weight_index + m];
02210
02211 top_sclr +=
02212 shadow_table[shade_index + 1*m + 0] *
02213 weight_table[weight_index + m];
02214 };
02215 shade_factor = top_opc * slice_depth_cueing;
02216
02217 top_clr *= shade_factor;
02218
02219 top_sclr *= shade_factor;
02220
02221 acc_opc += top_opc * wgtTR;
02222 acc_clr += (top_clr + top_sclr *
02223 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
02224
02225 #ifdef DEBUG
02226 if (ipixel == trace_pixel_ptr) {
02227 trace_opcTR = top_opc;
02228 trace_rclrTR = top_clr;
02229 trace_rsclrTR = top_sclr;
02230 }
02231 #endif
02232 ;
02233
02234 COUNT_RESAMPLE;
02235 if (acc_opc > min_opacity) {
02236 COUNT_COMPOSITE;
02237 iopc = ipixel->opcflt;
02238 # ifndef SKIP_ERT
02239 ASSERT(iopc < max_opacity);
02240 # endif
02241 iopc_inv = (float)1. - iopc;
02242 ipixel->clrflt += acc_clr * iopc_inv;
02243 iopc += acc_opc * iopc_inv;
02244 ipixel->opcflt = iopc;
02245
02246 #ifdef DEBUG
02247 if (ipixel == trace_pixel_ptr) {
02248 #ifdef COMPUTE_SHADOW_BUFFER
02249 printf("{%3d} %3d %3d", k, icount-i-count, j);
02250 #else
02251 printf("[%3d] %3d %3d", k, icount-i-count, j);
02252 #endif
02253 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02254 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02255 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02256 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02257 printf(" %3.0f %3.0f\n", iopc*255.,
02258 ipixel->clrflt);
02259
02260 printf(" ");
02261 printf(" %3.0f ",trace_rsclrTL);
02262 printf(" %3.0f ",trace_rsclrBL);
02263 printf(" %3.0f ",trace_rsclrTR);
02264 printf(" %3.0f ",trace_rsclrBR);
02265 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
02266
02267 }
02268 #endif
02269 ;
02270 # ifndef SKIP_ERT
02271 if (iopc >= max_opacity) {
02272 ASSERT(ipixel->lnk == 0);
02273 ipixel->lnk = 1;
02274 }
02275 # endif
02276 };
02277 ipixel += 1; shadow_pixel += 1;
02278 topRLEdata += 1 * voxel_istride;
02279 botRLEdata += 1 * voxel_istride;
02280 count--;
02281 SET_VOXELS_LOADED;
02282 }
02283 break;
02284 case ALL_NONZERO__TOP_NONZERO:
02285
02286
02287 if (!voxels_loaded) {
02288
02289
02290 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02291 opacity = param0_table[opac_param];
02292 if (param1_size != 0) {
02293 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02294 opacity *= param1_table[opac_param];
02295 if (param2_size != 0) {
02296 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02297 opacity *= param2_table[opac_param];
02298 }
02299 }
02300 if (opacity > min_opacity) {
02301 opacity_int = opacity*255.;
02302 top_opc = opac_correct[opacity_int];
02303 } else {
02304 top_opc = (float)0.;
02305 };
02306
02307
02308 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
02309 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
02310
02311
02312
02313 top_clr =
02314 shade_table[shade_index + 1*0 + 0] *
02315 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02316
02317 top_sclr =
02318 shadow_table[shade_index + 1*0 + 0] *
02319 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02320 for (m = 1; m < num_materials; m++) {
02321
02322
02323 top_clr +=
02324 shade_table[shade_index + 1*m + 0] *
02325 weight_table[weight_index + m];
02326
02327 top_sclr +=
02328 shadow_table[shade_index + 1*m + 0] *
02329 weight_table[weight_index + m];
02330 };
02331 shade_factor = top_opc * slice_depth_cueing;
02332
02333 top_clr *= shade_factor;
02334
02335 top_sclr *= shade_factor;
02336
02337
02338 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02339 opacity = param0_table[opac_param];
02340 if (param1_size != 0) {
02341 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02342 opacity *= param1_table[opac_param];
02343 if (param2_size != 0) {
02344 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02345 opacity *= param2_table[opac_param];
02346 }
02347 }
02348 if (opacity > min_opacity) {
02349 opacity_int = opacity*255.;
02350 bot_opc = opac_correct[opacity_int];
02351 } else {
02352 bot_opc = (float)0.;
02353 };
02354
02355
02356 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
02357 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
02358
02359
02360
02361 bot_clr =
02362 shade_table[shade_index + 1*0 + 0] *
02363 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02364
02365 bot_sclr =
02366 shadow_table[shade_index + 1*0 + 0] *
02367 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02368 for (m = 1; m < num_materials; m++) {
02369
02370
02371 bot_clr +=
02372 shade_table[shade_index + 1*m + 0] *
02373 weight_table[weight_index + m];
02374
02375 bot_sclr +=
02376 shadow_table[shade_index + 1*m + 0] *
02377 weight_table[weight_index + m];
02378 };
02379 shade_factor = bot_opc * slice_depth_cueing;
02380
02381 bot_clr *= shade_factor;
02382
02383 bot_sclr *= shade_factor;
02384 }
02385
02386 #ifdef DEBUG
02387 if (ipixel == trace_pixel_ptr) {
02388 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02389 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02390 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02391 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02392 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02393 }
02394 #endif
02395 ;
02396
02397 acc_opc = top_opc * wgtTL;
02398 acc_clr = (top_clr + top_sclr *
02399 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
02400
02401 #ifdef DEBUG
02402 if (ipixel == trace_pixel_ptr) {
02403 trace_opcTL = top_opc;
02404 trace_rclrTL = top_clr;
02405 trace_rsclrTL = top_sclr;
02406 }
02407 #endif
02408 ;
02409
02410 acc_opc += bot_opc * wgtBL;
02411 acc_clr += (bot_clr + bot_sclr *
02412 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
02413
02414 #ifdef DEBUG
02415 if (ipixel == trace_pixel_ptr) {
02416 trace_opcBL = bot_opc;
02417 trace_rclrBL = bot_clr;
02418 trace_rsclrBL = bot_sclr;
02419 }
02420 #endif
02421 ;
02422
02423
02424 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
02425 opacity = param0_table[opac_param];
02426 if (param1_size != 0) {
02427 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
02428 opacity *= param1_table[opac_param];
02429 if (param2_size != 0) {
02430 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
02431 opacity *= param2_table[opac_param];
02432 }
02433 }
02434 if (opacity > min_opacity) {
02435 opacity_int = opacity*255.;
02436 top_opc = opac_correct[opacity_int];
02437 } else {
02438 top_opc = (float)0.;
02439 };
02440
02441
02442 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
02443 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
02444
02445
02446
02447 top_clr =
02448 shade_table[shade_index + 1*0 + 0] *
02449 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02450
02451 top_sclr =
02452 shadow_table[shade_index + 1*0 + 0] *
02453 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02454 for (m = 1; m < num_materials; m++) {
02455
02456
02457 top_clr +=
02458 shade_table[shade_index + 1*m + 0] *
02459 weight_table[weight_index + m];
02460
02461 top_sclr +=
02462 shadow_table[shade_index + 1*m + 0] *
02463 weight_table[weight_index + m];
02464 };
02465 shade_factor = top_opc * slice_depth_cueing;
02466
02467 top_clr *= shade_factor;
02468
02469 top_sclr *= shade_factor;
02470
02471 acc_opc += top_opc * wgtTR;
02472 acc_clr += (top_clr + top_sclr *
02473 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
02474
02475 #ifdef DEBUG
02476 if (ipixel == trace_pixel_ptr) {
02477 trace_opcTR = top_opc;
02478 trace_rclrTR = top_clr;
02479 trace_rsclrTR = top_sclr;
02480 }
02481 #endif
02482 ;
02483
02484 COUNT_RESAMPLE;
02485 if (acc_opc > min_opacity) {
02486 COUNT_COMPOSITE;
02487 iopc = ipixel->opcflt;
02488 # ifndef SKIP_ERT
02489 ASSERT(iopc < max_opacity);
02490 # endif
02491 iopc_inv = (float)1. - iopc;
02492 ipixel->clrflt += acc_clr * iopc_inv;
02493 iopc += acc_opc * iopc_inv;
02494 ipixel->opcflt = iopc;
02495
02496 #ifdef DEBUG
02497 if (ipixel == trace_pixel_ptr) {
02498 #ifdef COMPUTE_SHADOW_BUFFER
02499 printf("{%3d} %3d %3d", k, icount-i-count, j);
02500 #else
02501 printf("[%3d] %3d %3d", k, icount-i-count, j);
02502 #endif
02503 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02504 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02505 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02506 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02507 printf(" %3.0f %3.0f\n", iopc*255.,
02508 ipixel->clrflt);
02509
02510 printf(" ");
02511 printf(" %3.0f ",trace_rsclrTL);
02512 printf(" %3.0f ",trace_rsclrBL);
02513 printf(" %3.0f ",trace_rsclrTR);
02514 printf(" %3.0f ",trace_rsclrBR);
02515 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
02516
02517 }
02518 #endif
02519 ;
02520 # ifndef SKIP_ERT
02521 if (iopc >= max_opacity) {
02522 ASSERT(ipixel->lnk == 0);
02523 ipixel->lnk = 1;
02524 }
02525 # endif
02526 };
02527 ipixel += 1; shadow_pixel += 1;
02528 topRLEdata += 1 * voxel_istride;
02529 botRLEdata += 1 * voxel_istride;
02530 count--;
02531 SET_VOXELS_LOADED;
02532
02533
02534
02535 while (count > 0) {
02536 if (PIXEL_IS_OPAQUE(ipixel))
02537 break;
02538 if (!voxels_loaded) {
02539
02540
02541 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
02542 opacity = param0_table[opac_param];
02543 if (param1_size != 0) {
02544 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
02545 opacity *= param1_table[opac_param];
02546 if (param2_size != 0) {
02547 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
02548 opacity *= param2_table[opac_param];
02549 }
02550 }
02551 if (opacity > min_opacity) {
02552 opacity_int = opacity*255.;
02553 top_opc = opac_correct[opacity_int];
02554 } else {
02555 top_opc = (float)0.;
02556 };
02557
02558
02559 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
02560 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
02561
02562
02563
02564 top_clr =
02565 shade_table[shade_index + 1*0 + 0] *
02566 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02567
02568 top_sclr =
02569 shadow_table[shade_index + 1*0 + 0] *
02570 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02571 for (m = 1; m < num_materials; m++) {
02572
02573
02574 top_clr +=
02575 shade_table[shade_index + 1*m + 0] *
02576 weight_table[weight_index + m];
02577
02578 top_sclr +=
02579 shadow_table[shade_index + 1*m + 0] *
02580 weight_table[weight_index + m];
02581 };
02582 shade_factor = top_opc * slice_depth_cueing;
02583
02584 top_clr *= shade_factor;
02585
02586 top_sclr *= shade_factor;
02587 }
02588
02589 #ifdef DEBUG
02590 if (ipixel == trace_pixel_ptr) {
02591 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02592 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02593 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02594 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02595 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02596 }
02597 #endif
02598 ;
02599
02600 acc_opc = top_opc * wgtTL;
02601 acc_clr = (top_clr + top_sclr *
02602 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
02603
02604 #ifdef DEBUG
02605 if (ipixel == trace_pixel_ptr) {
02606 trace_opcTL = top_opc;
02607 trace_rclrTL = top_clr;
02608 trace_rsclrTL = top_sclr;
02609 }
02610 #endif
02611 ;
02612
02613
02614 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
02615 opacity = param0_table[opac_param];
02616 if (param1_size != 0) {
02617 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
02618 opacity *= param1_table[opac_param];
02619 if (param2_size != 0) {
02620 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
02621 opacity *= param2_table[opac_param];
02622 }
02623 }
02624 if (opacity > min_opacity) {
02625 opacity_int = opacity*255.;
02626 top_opc = opac_correct[opacity_int];
02627 } else {
02628 top_opc = (float)0.;
02629 };
02630
02631
02632 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
02633 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
02634
02635
02636
02637 top_clr =
02638 shade_table[shade_index + 1*0 + 0] *
02639 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02640
02641 top_sclr =
02642 shadow_table[shade_index + 1*0 + 0] *
02643 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02644 for (m = 1; m < num_materials; m++) {
02645
02646
02647 top_clr +=
02648 shade_table[shade_index + 1*m + 0] *
02649 weight_table[weight_index + m];
02650
02651 top_sclr +=
02652 shadow_table[shade_index + 1*m + 0] *
02653 weight_table[weight_index + m];
02654 };
02655 shade_factor = top_opc * slice_depth_cueing;
02656
02657 top_clr *= shade_factor;
02658
02659 top_sclr *= shade_factor;
02660
02661 acc_opc += top_opc * wgtTR;
02662 acc_clr += (top_clr + top_sclr *
02663 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
02664
02665 #ifdef DEBUG
02666 if (ipixel == trace_pixel_ptr) {
02667 trace_opcTR = top_opc;
02668 trace_rclrTR = top_clr;
02669 trace_rsclrTR = top_sclr;
02670 }
02671 #endif
02672 ;
02673
02674 COUNT_RESAMPLE;
02675 if (acc_opc > min_opacity) {
02676 COUNT_COMPOSITE;
02677 iopc = ipixel->opcflt;
02678 # ifndef SKIP_ERT
02679 ASSERT(iopc < max_opacity);
02680 # endif
02681 iopc_inv = (float)1. - iopc;
02682 ipixel->clrflt += acc_clr * iopc_inv;
02683 iopc += acc_opc * iopc_inv;
02684 ipixel->opcflt = iopc;
02685
02686 #ifdef DEBUG
02687 if (ipixel == trace_pixel_ptr) {
02688 #ifdef COMPUTE_SHADOW_BUFFER
02689 printf("{%3d} %3d %3d", k, icount-i-count, j);
02690 #else
02691 printf("[%3d] %3d %3d", k, icount-i-count, j);
02692 #endif
02693 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02694 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02695 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02696 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02697 printf(" %3.0f %3.0f\n", iopc*255.,
02698 ipixel->clrflt);
02699
02700 printf(" ");
02701 printf(" %3.0f ",trace_rsclrTL);
02702 printf(" %3.0f ",trace_rsclrBL);
02703 printf(" %3.0f ",trace_rsclrTR);
02704 printf(" %3.0f ",trace_rsclrBR);
02705 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
02706
02707 }
02708 #endif
02709 ;
02710 # ifndef SKIP_ERT
02711 if (iopc >= max_opacity) {
02712 ASSERT(ipixel->lnk == 0);
02713 ipixel->lnk = 1;
02714 }
02715 # endif
02716 };
02717 ipixel += 1; shadow_pixel += 1;
02718 topRLEdata += 1 * voxel_istride;
02719 botRLEdata += 1 * voxel_istride;
02720 count--;
02721 SET_VOXELS_LOADED;
02722 }
02723 break;
02724 case ALL_ZERO__BOT_NONZERO:
02725
02726
02727
02728 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02729 opacity = param0_table[opac_param];
02730 if (param1_size != 0) {
02731 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02732 opacity *= param1_table[opac_param];
02733 if (param2_size != 0) {
02734 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02735 opacity *= param2_table[opac_param];
02736 }
02737 }
02738 if (opacity > min_opacity) {
02739 opacity_int = opacity*255.;
02740 bot_opc = opac_correct[opacity_int];
02741 } else {
02742 bot_opc = (float)0.;
02743 };
02744
02745
02746 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
02747 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
02748
02749
02750
02751 bot_clr =
02752 shade_table[shade_index + 1*0 + 0] *
02753 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02754
02755 bot_sclr =
02756 shadow_table[shade_index + 1*0 + 0] *
02757 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02758 for (m = 1; m < num_materials; m++) {
02759
02760
02761 bot_clr +=
02762 shade_table[shade_index + 1*m + 0] *
02763 weight_table[weight_index + m];
02764
02765 bot_sclr +=
02766 shadow_table[shade_index + 1*m + 0] *
02767 weight_table[weight_index + m];
02768 };
02769 shade_factor = bot_opc * slice_depth_cueing;
02770
02771 bot_clr *= shade_factor;
02772
02773 bot_sclr *= shade_factor;
02774
02775 #ifdef DEBUG
02776 if (ipixel == trace_pixel_ptr) {
02777 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02778 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02779 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02780 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02781 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02782 }
02783 #endif
02784 ;
02785
02786 acc_opc = bot_opc * wgtBR;
02787 acc_clr = (bot_clr + bot_sclr *
02788 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
02789
02790 #ifdef DEBUG
02791 if (ipixel == trace_pixel_ptr) {
02792 trace_opcBR = bot_opc;
02793 trace_rclrBR = bot_clr;
02794 trace_rsclrBR = bot_sclr;
02795 }
02796 #endif
02797 ;
02798
02799 COUNT_RESAMPLE;
02800 if (acc_opc > min_opacity) {
02801 COUNT_COMPOSITE;
02802 iopc = ipixel->opcflt;
02803 # ifndef SKIP_ERT
02804 ASSERT(iopc < max_opacity);
02805 # endif
02806 iopc_inv = (float)1. - iopc;
02807 ipixel->clrflt += acc_clr * iopc_inv;
02808 iopc += acc_opc * iopc_inv;
02809 ipixel->opcflt = iopc;
02810
02811 #ifdef DEBUG
02812 if (ipixel == trace_pixel_ptr) {
02813 #ifdef COMPUTE_SHADOW_BUFFER
02814 printf("{%3d} %3d %3d", k, icount-i-count, j);
02815 #else
02816 printf("[%3d] %3d %3d", k, icount-i-count, j);
02817 #endif
02818 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
02819 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
02820 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
02821 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
02822 printf(" %3.0f %3.0f\n", iopc*255.,
02823 ipixel->clrflt);
02824
02825 printf(" ");
02826 printf(" %3.0f ",trace_rsclrTL);
02827 printf(" %3.0f ",trace_rsclrBL);
02828 printf(" %3.0f ",trace_rsclrTR);
02829 printf(" %3.0f ",trace_rsclrBR);
02830 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
02831
02832 }
02833 #endif
02834 ;
02835 # ifndef SKIP_ERT
02836 if (iopc >= max_opacity) {
02837 ASSERT(ipixel->lnk == 0);
02838 ipixel->lnk = 1;
02839 }
02840 # endif
02841 };
02842 ipixel += 1; shadow_pixel += 1;
02843 topRLEdata += 1 * voxel_istride;
02844 botRLEdata += 1 * voxel_istride;
02845 count--;
02846 SET_VOXELS_LOADED;
02847
02848
02849
02850 while (count > 0) {
02851 if (PIXEL_IS_OPAQUE(ipixel))
02852 break;
02853 if (!voxels_loaded) {
02854
02855
02856 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
02857 opacity = param0_table[opac_param];
02858 if (param1_size != 0) {
02859 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
02860 opacity *= param1_table[opac_param];
02861 if (param2_size != 0) {
02862 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
02863 opacity *= param2_table[opac_param];
02864 }
02865 }
02866 if (opacity > min_opacity) {
02867 opacity_int = opacity*255.;
02868 bot_opc = opac_correct[opacity_int];
02869 } else {
02870 bot_opc = (float)0.;
02871 };
02872
02873
02874 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
02875 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
02876
02877
02878
02879 bot_clr =
02880 shade_table[shade_index + 1*0 + 0] *
02881 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02882
02883 bot_sclr =
02884 shadow_table[shade_index + 1*0 + 0] *
02885 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02886 for (m = 1; m < num_materials; m++) {
02887
02888
02889 bot_clr +=
02890 shade_table[shade_index + 1*m + 0] *
02891 weight_table[weight_index + m];
02892
02893 bot_sclr +=
02894 shadow_table[shade_index + 1*m + 0] *
02895 weight_table[weight_index + m];
02896 };
02897 shade_factor = bot_opc * slice_depth_cueing;
02898
02899 bot_clr *= shade_factor;
02900
02901 bot_sclr *= shade_factor;
02902 }
02903
02904 #ifdef DEBUG
02905 if (ipixel == trace_pixel_ptr) {
02906 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
02907 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
02908 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
02909 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
02910 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
02911 }
02912 #endif
02913 ;
02914
02915 acc_opc = bot_opc * wgtBL;
02916 acc_clr = (bot_clr + bot_sclr *
02917 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
02918
02919 #ifdef DEBUG
02920 if (ipixel == trace_pixel_ptr) {
02921 trace_opcBL = bot_opc;
02922 trace_rclrBL = bot_clr;
02923 trace_rsclrBL = bot_sclr;
02924 }
02925 #endif
02926 ;
02927
02928
02929 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
02930 opacity = param0_table[opac_param];
02931 if (param1_size != 0) {
02932 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
02933 opacity *= param1_table[opac_param];
02934 if (param2_size != 0) {
02935 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
02936 opacity *= param2_table[opac_param];
02937 }
02938 }
02939 if (opacity > min_opacity) {
02940 opacity_int = opacity*255.;
02941 bot_opc = opac_correct[opacity_int];
02942 } else {
02943 bot_opc = (float)0.;
02944 };
02945
02946
02947 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
02948 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
02949
02950
02951
02952 bot_clr =
02953 shade_table[shade_index + 1*0 + 0] *
02954 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02955
02956 bot_sclr =
02957 shadow_table[shade_index + 1*0 + 0] *
02958 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
02959 for (m = 1; m < num_materials; m++) {
02960
02961
02962 bot_clr +=
02963 shade_table[shade_index + 1*m + 0] *
02964 weight_table[weight_index + m];
02965
02966 bot_sclr +=
02967 shadow_table[shade_index + 1*m + 0] *
02968 weight_table[weight_index + m];
02969 };
02970 shade_factor = bot_opc * slice_depth_cueing;
02971
02972 bot_clr *= shade_factor;
02973
02974 bot_sclr *= shade_factor;
02975
02976 acc_opc += bot_opc * wgtBR;
02977 acc_clr += (bot_clr + bot_sclr *
02978 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
02979
02980 #ifdef DEBUG
02981 if (ipixel == trace_pixel_ptr) {
02982 trace_opcBR = bot_opc;
02983 trace_rclrBR = bot_clr;
02984 trace_rsclrBR = bot_sclr;
02985 }
02986 #endif
02987 ;
02988
02989 COUNT_RESAMPLE;
02990 if (acc_opc > min_opacity) {
02991 COUNT_COMPOSITE;
02992 iopc = ipixel->opcflt;
02993 # ifndef SKIP_ERT
02994 ASSERT(iopc < max_opacity);
02995 # endif
02996 iopc_inv = (float)1. - iopc;
02997 ipixel->clrflt += acc_clr * iopc_inv;
02998 iopc += acc_opc * iopc_inv;
02999 ipixel->opcflt = iopc;
03000
03001 #ifdef DEBUG
03002 if (ipixel == trace_pixel_ptr) {
03003 #ifdef COMPUTE_SHADOW_BUFFER
03004 printf("{%3d} %3d %3d", k, icount-i-count, j);
03005 #else
03006 printf("[%3d] %3d %3d", k, icount-i-count, j);
03007 #endif
03008 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03009 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03010 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03011 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03012 printf(" %3.0f %3.0f\n", iopc*255.,
03013 ipixel->clrflt);
03014
03015 printf(" ");
03016 printf(" %3.0f ",trace_rsclrTL);
03017 printf(" %3.0f ",trace_rsclrBL);
03018 printf(" %3.0f ",trace_rsclrTR);
03019 printf(" %3.0f ",trace_rsclrBR);
03020 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
03021
03022 }
03023 #endif
03024 ;
03025 # ifndef SKIP_ERT
03026 if (iopc >= max_opacity) {
03027 ASSERT(ipixel->lnk == 0);
03028 ipixel->lnk = 1;
03029 }
03030 # endif
03031 };
03032 ipixel += 1; shadow_pixel += 1;
03033 topRLEdata += 1 * voxel_istride;
03034 botRLEdata += 1 * voxel_istride;
03035 count--;
03036 SET_VOXELS_LOADED;
03037 }
03038 break;
03039 case TOP_NONZERO__BOT_NONZERO:
03040
03041 if (!voxels_loaded) {
03042
03043
03044 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03045 opacity = param0_table[opac_param];
03046 if (param1_size != 0) {
03047 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03048 opacity *= param1_table[opac_param];
03049 if (param2_size != 0) {
03050 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03051 opacity *= param2_table[opac_param];
03052 }
03053 }
03054 if (opacity > min_opacity) {
03055 opacity_int = opacity*255.;
03056 top_opc = opac_correct[opacity_int];
03057 } else {
03058 top_opc = (float)0.;
03059 };
03060
03061
03062 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
03063 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
03064
03065
03066
03067 top_clr =
03068 shade_table[shade_index + 1*0 + 0] *
03069 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03070
03071 top_sclr =
03072 shadow_table[shade_index + 1*0 + 0] *
03073 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03074 for (m = 1; m < num_materials; m++) {
03075
03076
03077 top_clr +=
03078 shade_table[shade_index + 1*m + 0] *
03079 weight_table[weight_index + m];
03080
03081 top_sclr +=
03082 shadow_table[shade_index + 1*m + 0] *
03083 weight_table[weight_index + m];
03084 };
03085 shade_factor = top_opc * slice_depth_cueing;
03086
03087 top_clr *= shade_factor;
03088
03089 top_sclr *= shade_factor;
03090 }
03091
03092 #ifdef DEBUG
03093 if (ipixel == trace_pixel_ptr) {
03094 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03095 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03096 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03097 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03098 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03099 }
03100 #endif
03101 ;
03102
03103 acc_opc = top_opc * wgtTL;
03104 acc_clr = (top_clr + top_sclr *
03105 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
03106
03107 #ifdef DEBUG
03108 if (ipixel == trace_pixel_ptr) {
03109 trace_opcTL = top_opc;
03110 trace_rclrTL = top_clr;
03111 trace_rsclrTL = top_sclr;
03112 }
03113 #endif
03114 ;
03115
03116
03117 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03118 opacity = param0_table[opac_param];
03119 if (param1_size != 0) {
03120 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03121 opacity *= param1_table[opac_param];
03122 if (param2_size != 0) {
03123 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03124 opacity *= param2_table[opac_param];
03125 }
03126 }
03127 if (opacity > min_opacity) {
03128 opacity_int = opacity*255.;
03129 bot_opc = opac_correct[opacity_int];
03130 } else {
03131 bot_opc = (float)0.;
03132 };
03133
03134
03135 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
03136 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
03137
03138
03139
03140 bot_clr =
03141 shade_table[shade_index + 1*0 + 0] *
03142 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03143
03144 bot_sclr =
03145 shadow_table[shade_index + 1*0 + 0] *
03146 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03147 for (m = 1; m < num_materials; m++) {
03148
03149
03150 bot_clr +=
03151 shade_table[shade_index + 1*m + 0] *
03152 weight_table[weight_index + m];
03153
03154 bot_sclr +=
03155 shadow_table[shade_index + 1*m + 0] *
03156 weight_table[weight_index + m];
03157 };
03158 shade_factor = bot_opc * slice_depth_cueing;
03159
03160 bot_clr *= shade_factor;
03161
03162 bot_sclr *= shade_factor;
03163
03164 acc_opc += bot_opc * wgtBR;
03165 acc_clr += (bot_clr + bot_sclr *
03166 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
03167
03168 #ifdef DEBUG
03169 if (ipixel == trace_pixel_ptr) {
03170 trace_opcBR = bot_opc;
03171 trace_rclrBR = bot_clr;
03172 trace_rsclrBR = bot_sclr;
03173 }
03174 #endif
03175 ;
03176
03177 COUNT_RESAMPLE;
03178 if (acc_opc > min_opacity) {
03179 COUNT_COMPOSITE;
03180 iopc = ipixel->opcflt;
03181 # ifndef SKIP_ERT
03182 ASSERT(iopc < max_opacity);
03183 # endif
03184 iopc_inv = (float)1. - iopc;
03185 ipixel->clrflt += acc_clr * iopc_inv;
03186 iopc += acc_opc * iopc_inv;
03187 ipixel->opcflt = iopc;
03188
03189 #ifdef DEBUG
03190 if (ipixel == trace_pixel_ptr) {
03191 #ifdef COMPUTE_SHADOW_BUFFER
03192 printf("{%3d} %3d %3d", k, icount-i-count, j);
03193 #else
03194 printf("[%3d] %3d %3d", k, icount-i-count, j);
03195 #endif
03196 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03197 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03198 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03199 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03200 printf(" %3.0f %3.0f\n", iopc*255.,
03201 ipixel->clrflt);
03202
03203 printf(" ");
03204 printf(" %3.0f ",trace_rsclrTL);
03205 printf(" %3.0f ",trace_rsclrBL);
03206 printf(" %3.0f ",trace_rsclrTR);
03207 printf(" %3.0f ",trace_rsclrBR);
03208 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
03209
03210 }
03211 #endif
03212 ;
03213 # ifndef SKIP_ERT
03214 if (iopc >= max_opacity) {
03215 ASSERT(ipixel->lnk == 0);
03216 ipixel->lnk = 1;
03217 }
03218 # endif
03219 };
03220 ipixel += 1; shadow_pixel += 1;
03221 topRLEdata += 1 * voxel_istride;
03222 botRLEdata += 1 * voxel_istride;
03223 count--;
03224 SET_VOXELS_LOADED;
03225
03226
03227
03228 while (count > 0) {
03229 if (PIXEL_IS_OPAQUE(ipixel))
03230 break;
03231 if (!voxels_loaded) {
03232
03233
03234 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03235 opacity = param0_table[opac_param];
03236 if (param1_size != 0) {
03237 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03238 opacity *= param1_table[opac_param];
03239 if (param2_size != 0) {
03240 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03241 opacity *= param2_table[opac_param];
03242 }
03243 }
03244 if (opacity > min_opacity) {
03245 opacity_int = opacity*255.;
03246 bot_opc = opac_correct[opacity_int];
03247 } else {
03248 bot_opc = (float)0.;
03249 };
03250
03251
03252 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
03253 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
03254
03255
03256
03257 bot_clr =
03258 shade_table[shade_index + 1*0 + 0] *
03259 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03260
03261 bot_sclr =
03262 shadow_table[shade_index + 1*0 + 0] *
03263 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03264 for (m = 1; m < num_materials; m++) {
03265
03266
03267 bot_clr +=
03268 shade_table[shade_index + 1*m + 0] *
03269 weight_table[weight_index + m];
03270
03271 bot_sclr +=
03272 shadow_table[shade_index + 1*m + 0] *
03273 weight_table[weight_index + m];
03274 };
03275 shade_factor = bot_opc * slice_depth_cueing;
03276
03277 bot_clr *= shade_factor;
03278
03279 bot_sclr *= shade_factor;
03280 }
03281
03282 #ifdef DEBUG
03283 if (ipixel == trace_pixel_ptr) {
03284 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03285 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03286 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03287 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03288 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03289 }
03290 #endif
03291 ;
03292
03293 acc_opc = bot_opc * wgtBL;
03294 acc_clr = (bot_clr + bot_sclr *
03295 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
03296
03297 #ifdef DEBUG
03298 if (ipixel == trace_pixel_ptr) {
03299 trace_opcBL = bot_opc;
03300 trace_rclrBL = bot_clr;
03301 trace_rsclrBL = bot_sclr;
03302 }
03303 #endif
03304 ;
03305
03306
03307 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03308 opacity = param0_table[opac_param];
03309 if (param1_size != 0) {
03310 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03311 opacity *= param1_table[opac_param];
03312 if (param2_size != 0) {
03313 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03314 opacity *= param2_table[opac_param];
03315 }
03316 }
03317 if (opacity > min_opacity) {
03318 opacity_int = opacity*255.;
03319 bot_opc = opac_correct[opacity_int];
03320 } else {
03321 bot_opc = (float)0.;
03322 };
03323
03324
03325 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
03326 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
03327
03328
03329
03330 bot_clr =
03331 shade_table[shade_index + 1*0 + 0] *
03332 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03333
03334 bot_sclr =
03335 shadow_table[shade_index + 1*0 + 0] *
03336 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03337 for (m = 1; m < num_materials; m++) {
03338
03339
03340 bot_clr +=
03341 shade_table[shade_index + 1*m + 0] *
03342 weight_table[weight_index + m];
03343
03344 bot_sclr +=
03345 shadow_table[shade_index + 1*m + 0] *
03346 weight_table[weight_index + m];
03347 };
03348 shade_factor = bot_opc * slice_depth_cueing;
03349
03350 bot_clr *= shade_factor;
03351
03352 bot_sclr *= shade_factor;
03353
03354 acc_opc += bot_opc * wgtBR;
03355 acc_clr += (bot_clr + bot_sclr *
03356 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
03357
03358 #ifdef DEBUG
03359 if (ipixel == trace_pixel_ptr) {
03360 trace_opcBR = bot_opc;
03361 trace_rclrBR = bot_clr;
03362 trace_rsclrBR = bot_sclr;
03363 }
03364 #endif
03365 ;
03366
03367 COUNT_RESAMPLE;
03368 if (acc_opc > min_opacity) {
03369 COUNT_COMPOSITE;
03370 iopc = ipixel->opcflt;
03371 # ifndef SKIP_ERT
03372 ASSERT(iopc < max_opacity);
03373 # endif
03374 iopc_inv = (float)1. - iopc;
03375 ipixel->clrflt += acc_clr * iopc_inv;
03376 iopc += acc_opc * iopc_inv;
03377 ipixel->opcflt = iopc;
03378
03379 #ifdef DEBUG
03380 if (ipixel == trace_pixel_ptr) {
03381 #ifdef COMPUTE_SHADOW_BUFFER
03382 printf("{%3d} %3d %3d", k, icount-i-count, j);
03383 #else
03384 printf("[%3d] %3d %3d", k, icount-i-count, j);
03385 #endif
03386 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03387 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03388 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03389 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03390 printf(" %3.0f %3.0f\n", iopc*255.,
03391 ipixel->clrflt);
03392
03393 printf(" ");
03394 printf(" %3.0f ",trace_rsclrTL);
03395 printf(" %3.0f ",trace_rsclrBL);
03396 printf(" %3.0f ",trace_rsclrTR);
03397 printf(" %3.0f ",trace_rsclrBR);
03398 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
03399
03400 }
03401 #endif
03402 ;
03403 # ifndef SKIP_ERT
03404 if (iopc >= max_opacity) {
03405 ASSERT(ipixel->lnk == 0);
03406 ipixel->lnk = 1;
03407 }
03408 # endif
03409 };
03410 ipixel += 1; shadow_pixel += 1;
03411 topRLEdata += 1 * voxel_istride;
03412 botRLEdata += 1 * voxel_istride;
03413 count--;
03414 SET_VOXELS_LOADED;
03415 }
03416 break;
03417 case BOT_NONZERO__BOT_NONZERO:
03418
03419
03420 while (count > 0) {
03421 if (PIXEL_IS_OPAQUE(ipixel))
03422 break;
03423 if (!voxels_loaded) {
03424
03425
03426 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03427 opacity = param0_table[opac_param];
03428 if (param1_size != 0) {
03429 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03430 opacity *= param1_table[opac_param];
03431 if (param2_size != 0) {
03432 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03433 opacity *= param2_table[opac_param];
03434 }
03435 }
03436 if (opacity > min_opacity) {
03437 opacity_int = opacity*255.;
03438 bot_opc = opac_correct[opacity_int];
03439 } else {
03440 bot_opc = (float)0.;
03441 };
03442
03443
03444 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
03445 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
03446
03447
03448
03449 bot_clr =
03450 shade_table[shade_index + 1*0 + 0] *
03451 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03452
03453 bot_sclr =
03454 shadow_table[shade_index + 1*0 + 0] *
03455 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03456 for (m = 1; m < num_materials; m++) {
03457
03458
03459 bot_clr +=
03460 shade_table[shade_index + 1*m + 0] *
03461 weight_table[weight_index + m];
03462
03463 bot_sclr +=
03464 shadow_table[shade_index + 1*m + 0] *
03465 weight_table[weight_index + m];
03466 };
03467 shade_factor = bot_opc * slice_depth_cueing;
03468
03469 bot_clr *= shade_factor;
03470
03471 bot_sclr *= shade_factor;
03472 }
03473
03474 #ifdef DEBUG
03475 if (ipixel == trace_pixel_ptr) {
03476 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03477 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03478 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03479 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03480 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03481 }
03482 #endif
03483 ;
03484
03485 acc_opc = bot_opc * wgtBL;
03486 acc_clr = (bot_clr + bot_sclr *
03487 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
03488
03489 #ifdef DEBUG
03490 if (ipixel == trace_pixel_ptr) {
03491 trace_opcBL = bot_opc;
03492 trace_rclrBL = bot_clr;
03493 trace_rsclrBL = bot_sclr;
03494 }
03495 #endif
03496 ;
03497
03498
03499 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03500 opacity = param0_table[opac_param];
03501 if (param1_size != 0) {
03502 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03503 opacity *= param1_table[opac_param];
03504 if (param2_size != 0) {
03505 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03506 opacity *= param2_table[opac_param];
03507 }
03508 }
03509 if (opacity > min_opacity) {
03510 opacity_int = opacity*255.;
03511 bot_opc = opac_correct[opacity_int];
03512 } else {
03513 bot_opc = (float)0.;
03514 };
03515
03516
03517 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
03518 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
03519
03520
03521
03522 bot_clr =
03523 shade_table[shade_index + 1*0 + 0] *
03524 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03525
03526 bot_sclr =
03527 shadow_table[shade_index + 1*0 + 0] *
03528 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03529 for (m = 1; m < num_materials; m++) {
03530
03531
03532 bot_clr +=
03533 shade_table[shade_index + 1*m + 0] *
03534 weight_table[weight_index + m];
03535
03536 bot_sclr +=
03537 shadow_table[shade_index + 1*m + 0] *
03538 weight_table[weight_index + m];
03539 };
03540 shade_factor = bot_opc * slice_depth_cueing;
03541
03542 bot_clr *= shade_factor;
03543
03544 bot_sclr *= shade_factor;
03545
03546 acc_opc += bot_opc * wgtBR;
03547 acc_clr += (bot_clr + bot_sclr *
03548 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
03549
03550 #ifdef DEBUG
03551 if (ipixel == trace_pixel_ptr) {
03552 trace_opcBR = bot_opc;
03553 trace_rclrBR = bot_clr;
03554 trace_rsclrBR = bot_sclr;
03555 }
03556 #endif
03557 ;
03558
03559 COUNT_RESAMPLE;
03560 if (acc_opc > min_opacity) {
03561 COUNT_COMPOSITE;
03562 iopc = ipixel->opcflt;
03563 # ifndef SKIP_ERT
03564 ASSERT(iopc < max_opacity);
03565 # endif
03566 iopc_inv = (float)1. - iopc;
03567 ipixel->clrflt += acc_clr * iopc_inv;
03568 iopc += acc_opc * iopc_inv;
03569 ipixel->opcflt = iopc;
03570
03571 #ifdef DEBUG
03572 if (ipixel == trace_pixel_ptr) {
03573 #ifdef COMPUTE_SHADOW_BUFFER
03574 printf("{%3d} %3d %3d", k, icount-i-count, j);
03575 #else
03576 printf("[%3d] %3d %3d", k, icount-i-count, j);
03577 #endif
03578 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03579 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03580 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03581 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03582 printf(" %3.0f %3.0f\n", iopc*255.,
03583 ipixel->clrflt);
03584
03585 printf(" ");
03586 printf(" %3.0f ",trace_rsclrTL);
03587 printf(" %3.0f ",trace_rsclrBL);
03588 printf(" %3.0f ",trace_rsclrTR);
03589 printf(" %3.0f ",trace_rsclrBR);
03590 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
03591
03592 }
03593 #endif
03594 ;
03595 # ifndef SKIP_ERT
03596 if (iopc >= max_opacity) {
03597 ASSERT(ipixel->lnk == 0);
03598 ipixel->lnk = 1;
03599 }
03600 # endif
03601 };
03602 ipixel += 1; shadow_pixel += 1;
03603 topRLEdata += 1 * voxel_istride;
03604 botRLEdata += 1 * voxel_istride;
03605 count--;
03606 SET_VOXELS_LOADED;
03607 }
03608 break;
03609 case ALL_NONZERO__BOT_NONZERO:
03610
03611
03612 if (!voxels_loaded) {
03613
03614
03615 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
03616 opacity = param0_table[opac_param];
03617 if (param1_size != 0) {
03618 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
03619 opacity *= param1_table[opac_param];
03620 if (param2_size != 0) {
03621 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
03622 opacity *= param2_table[opac_param];
03623 }
03624 }
03625 if (opacity > min_opacity) {
03626 opacity_int = opacity*255.;
03627 top_opc = opac_correct[opacity_int];
03628 } else {
03629 top_opc = (float)0.;
03630 };
03631
03632
03633 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
03634 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
03635
03636
03637
03638 top_clr =
03639 shade_table[shade_index + 1*0 + 0] *
03640 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03641
03642 top_sclr =
03643 shadow_table[shade_index + 1*0 + 0] *
03644 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03645 for (m = 1; m < num_materials; m++) {
03646
03647
03648 top_clr +=
03649 shade_table[shade_index + 1*m + 0] *
03650 weight_table[weight_index + m];
03651
03652 top_sclr +=
03653 shadow_table[shade_index + 1*m + 0] *
03654 weight_table[weight_index + m];
03655 };
03656 shade_factor = top_opc * slice_depth_cueing;
03657
03658 top_clr *= shade_factor;
03659
03660 top_sclr *= shade_factor;
03661
03662
03663 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03664 opacity = param0_table[opac_param];
03665 if (param1_size != 0) {
03666 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03667 opacity *= param1_table[opac_param];
03668 if (param2_size != 0) {
03669 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03670 opacity *= param2_table[opac_param];
03671 }
03672 }
03673 if (opacity > min_opacity) {
03674 opacity_int = opacity*255.;
03675 bot_opc = opac_correct[opacity_int];
03676 } else {
03677 bot_opc = (float)0.;
03678 };
03679
03680
03681 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
03682 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
03683
03684
03685
03686 bot_clr =
03687 shade_table[shade_index + 1*0 + 0] *
03688 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03689
03690 bot_sclr =
03691 shadow_table[shade_index + 1*0 + 0] *
03692 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03693 for (m = 1; m < num_materials; m++) {
03694
03695
03696 bot_clr +=
03697 shade_table[shade_index + 1*m + 0] *
03698 weight_table[weight_index + m];
03699
03700 bot_sclr +=
03701 shadow_table[shade_index + 1*m + 0] *
03702 weight_table[weight_index + m];
03703 };
03704 shade_factor = bot_opc * slice_depth_cueing;
03705
03706 bot_clr *= shade_factor;
03707
03708 bot_sclr *= shade_factor;
03709 }
03710
03711 #ifdef DEBUG
03712 if (ipixel == trace_pixel_ptr) {
03713 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03714 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03715 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03716 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03717 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03718 }
03719 #endif
03720 ;
03721
03722 acc_opc = top_opc * wgtTL;
03723 acc_clr = (top_clr + top_sclr *
03724 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
03725
03726 #ifdef DEBUG
03727 if (ipixel == trace_pixel_ptr) {
03728 trace_opcTL = top_opc;
03729 trace_rclrTL = top_clr;
03730 trace_rsclrTL = top_sclr;
03731 }
03732 #endif
03733 ;
03734
03735 acc_opc += bot_opc * wgtBL;
03736 acc_clr += (bot_clr + bot_sclr *
03737 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
03738
03739 #ifdef DEBUG
03740 if (ipixel == trace_pixel_ptr) {
03741 trace_opcBL = bot_opc;
03742 trace_rclrBL = bot_clr;
03743 trace_rsclrBL = bot_sclr;
03744 }
03745 #endif
03746 ;
03747
03748
03749 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03750 opacity = param0_table[opac_param];
03751 if (param1_size != 0) {
03752 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03753 opacity *= param1_table[opac_param];
03754 if (param2_size != 0) {
03755 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03756 opacity *= param2_table[opac_param];
03757 }
03758 }
03759 if (opacity > min_opacity) {
03760 opacity_int = opacity*255.;
03761 bot_opc = opac_correct[opacity_int];
03762 } else {
03763 bot_opc = (float)0.;
03764 };
03765
03766
03767 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
03768 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
03769
03770
03771
03772 bot_clr =
03773 shade_table[shade_index + 1*0 + 0] *
03774 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03775
03776 bot_sclr =
03777 shadow_table[shade_index + 1*0 + 0] *
03778 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03779 for (m = 1; m < num_materials; m++) {
03780
03781
03782 bot_clr +=
03783 shade_table[shade_index + 1*m + 0] *
03784 weight_table[weight_index + m];
03785
03786 bot_sclr +=
03787 shadow_table[shade_index + 1*m + 0] *
03788 weight_table[weight_index + m];
03789 };
03790 shade_factor = bot_opc * slice_depth_cueing;
03791
03792 bot_clr *= shade_factor;
03793
03794 bot_sclr *= shade_factor;
03795
03796 acc_opc += bot_opc * wgtBR;
03797 acc_clr += (bot_clr + bot_sclr *
03798 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
03799
03800 #ifdef DEBUG
03801 if (ipixel == trace_pixel_ptr) {
03802 trace_opcBR = bot_opc;
03803 trace_rclrBR = bot_clr;
03804 trace_rsclrBR = bot_sclr;
03805 }
03806 #endif
03807 ;
03808
03809 COUNT_RESAMPLE;
03810 if (acc_opc > min_opacity) {
03811 COUNT_COMPOSITE;
03812 iopc = ipixel->opcflt;
03813 # ifndef SKIP_ERT
03814 ASSERT(iopc < max_opacity);
03815 # endif
03816 iopc_inv = (float)1. - iopc;
03817 ipixel->clrflt += acc_clr * iopc_inv;
03818 iopc += acc_opc * iopc_inv;
03819 ipixel->opcflt = iopc;
03820
03821 #ifdef DEBUG
03822 if (ipixel == trace_pixel_ptr) {
03823 #ifdef COMPUTE_SHADOW_BUFFER
03824 printf("{%3d} %3d %3d", k, icount-i-count, j);
03825 #else
03826 printf("[%3d] %3d %3d", k, icount-i-count, j);
03827 #endif
03828 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
03829 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
03830 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
03831 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
03832 printf(" %3.0f %3.0f\n", iopc*255.,
03833 ipixel->clrflt);
03834
03835 printf(" ");
03836 printf(" %3.0f ",trace_rsclrTL);
03837 printf(" %3.0f ",trace_rsclrBL);
03838 printf(" %3.0f ",trace_rsclrTR);
03839 printf(" %3.0f ",trace_rsclrBR);
03840 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
03841
03842 }
03843 #endif
03844 ;
03845 # ifndef SKIP_ERT
03846 if (iopc >= max_opacity) {
03847 ASSERT(ipixel->lnk == 0);
03848 ipixel->lnk = 1;
03849 }
03850 # endif
03851 };
03852 ipixel += 1; shadow_pixel += 1;
03853 topRLEdata += 1 * voxel_istride;
03854 botRLEdata += 1 * voxel_istride;
03855 count--;
03856 SET_VOXELS_LOADED;
03857
03858
03859
03860 while (count > 0) {
03861 if (PIXEL_IS_OPAQUE(ipixel))
03862 break;
03863 if (!voxels_loaded) {
03864
03865
03866 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
03867 opacity = param0_table[opac_param];
03868 if (param1_size != 0) {
03869 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
03870 opacity *= param1_table[opac_param];
03871 if (param2_size != 0) {
03872 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
03873 opacity *= param2_table[opac_param];
03874 }
03875 }
03876 if (opacity > min_opacity) {
03877 opacity_int = opacity*255.;
03878 bot_opc = opac_correct[opacity_int];
03879 } else {
03880 bot_opc = (float)0.;
03881 };
03882
03883
03884 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
03885 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
03886
03887
03888
03889 bot_clr =
03890 shade_table[shade_index + 1*0 + 0] *
03891 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03892
03893 bot_sclr =
03894 shadow_table[shade_index + 1*0 + 0] *
03895 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03896 for (m = 1; m < num_materials; m++) {
03897
03898
03899 bot_clr +=
03900 shade_table[shade_index + 1*m + 0] *
03901 weight_table[weight_index + m];
03902
03903 bot_sclr +=
03904 shadow_table[shade_index + 1*m + 0] *
03905 weight_table[weight_index + m];
03906 };
03907 shade_factor = bot_opc * slice_depth_cueing;
03908
03909 bot_clr *= shade_factor;
03910
03911 bot_sclr *= shade_factor;
03912 }
03913
03914 #ifdef DEBUG
03915 if (ipixel == trace_pixel_ptr) {
03916 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
03917 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
03918 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
03919 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
03920 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
03921 }
03922 #endif
03923 ;
03924
03925 acc_opc = bot_opc * wgtBL;
03926 acc_clr = (bot_clr + bot_sclr *
03927 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
03928
03929 #ifdef DEBUG
03930 if (ipixel == trace_pixel_ptr) {
03931 trace_opcBL = bot_opc;
03932 trace_rclrBL = bot_clr;
03933 trace_rsclrBL = bot_sclr;
03934 }
03935 #endif
03936 ;
03937
03938
03939 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
03940 opacity = param0_table[opac_param];
03941 if (param1_size != 0) {
03942 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
03943 opacity *= param1_table[opac_param];
03944 if (param2_size != 0) {
03945 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
03946 opacity *= param2_table[opac_param];
03947 }
03948 }
03949 if (opacity > min_opacity) {
03950 opacity_int = opacity*255.;
03951 bot_opc = opac_correct[opacity_int];
03952 } else {
03953 bot_opc = (float)0.;
03954 };
03955
03956
03957 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
03958 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
03959
03960
03961
03962 bot_clr =
03963 shade_table[shade_index + 1*0 + 0] *
03964 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03965
03966 bot_sclr =
03967 shadow_table[shade_index + 1*0 + 0] *
03968 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
03969 for (m = 1; m < num_materials; m++) {
03970
03971
03972 bot_clr +=
03973 shade_table[shade_index + 1*m + 0] *
03974 weight_table[weight_index + m];
03975
03976 bot_sclr +=
03977 shadow_table[shade_index + 1*m + 0] *
03978 weight_table[weight_index + m];
03979 };
03980 shade_factor = bot_opc * slice_depth_cueing;
03981
03982 bot_clr *= shade_factor;
03983
03984 bot_sclr *= shade_factor;
03985
03986 acc_opc += bot_opc * wgtBR;
03987 acc_clr += (bot_clr + bot_sclr *
03988 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
03989
03990 #ifdef DEBUG
03991 if (ipixel == trace_pixel_ptr) {
03992 trace_opcBR = bot_opc;
03993 trace_rclrBR = bot_clr;
03994 trace_rsclrBR = bot_sclr;
03995 }
03996 #endif
03997 ;
03998
03999 COUNT_RESAMPLE;
04000 if (acc_opc > min_opacity) {
04001 COUNT_COMPOSITE;
04002 iopc = ipixel->opcflt;
04003 # ifndef SKIP_ERT
04004 ASSERT(iopc < max_opacity);
04005 # endif
04006 iopc_inv = (float)1. - iopc;
04007 ipixel->clrflt += acc_clr * iopc_inv;
04008 iopc += acc_opc * iopc_inv;
04009 ipixel->opcflt = iopc;
04010
04011 #ifdef DEBUG
04012 if (ipixel == trace_pixel_ptr) {
04013 #ifdef COMPUTE_SHADOW_BUFFER
04014 printf("{%3d} %3d %3d", k, icount-i-count, j);
04015 #else
04016 printf("[%3d] %3d %3d", k, icount-i-count, j);
04017 #endif
04018 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04019 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04020 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04021 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04022 printf(" %3.0f %3.0f\n", iopc*255.,
04023 ipixel->clrflt);
04024
04025 printf(" ");
04026 printf(" %3.0f ",trace_rsclrTL);
04027 printf(" %3.0f ",trace_rsclrBL);
04028 printf(" %3.0f ",trace_rsclrTR);
04029 printf(" %3.0f ",trace_rsclrBR);
04030 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
04031
04032 }
04033 #endif
04034 ;
04035 # ifndef SKIP_ERT
04036 if (iopc >= max_opacity) {
04037 ASSERT(ipixel->lnk == 0);
04038 ipixel->lnk = 1;
04039 }
04040 # endif
04041 };
04042 ipixel += 1; shadow_pixel += 1;
04043 topRLEdata += 1 * voxel_istride;
04044 botRLEdata += 1 * voxel_istride;
04045 count--;
04046 SET_VOXELS_LOADED;
04047 }
04048 break;
04049 case ALL_ZERO__ALL_NONZERO:
04050
04051
04052
04053 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04054 opacity = param0_table[opac_param];
04055 if (param1_size != 0) {
04056 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04057 opacity *= param1_table[opac_param];
04058 if (param2_size != 0) {
04059 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04060 opacity *= param2_table[opac_param];
04061 }
04062 }
04063 if (opacity > min_opacity) {
04064 opacity_int = opacity*255.;
04065 top_opc = opac_correct[opacity_int];
04066 } else {
04067 top_opc = (float)0.;
04068 };
04069
04070
04071 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
04072 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
04073
04074
04075
04076 top_clr =
04077 shade_table[shade_index + 1*0 + 0] *
04078 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04079
04080 top_sclr =
04081 shadow_table[shade_index + 1*0 + 0] *
04082 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04083 for (m = 1; m < num_materials; m++) {
04084
04085
04086 top_clr +=
04087 shade_table[shade_index + 1*m + 0] *
04088 weight_table[weight_index + m];
04089
04090 top_sclr +=
04091 shadow_table[shade_index + 1*m + 0] *
04092 weight_table[weight_index + m];
04093 };
04094 shade_factor = top_opc * slice_depth_cueing;
04095
04096 top_clr *= shade_factor;
04097
04098 top_sclr *= shade_factor;
04099
04100
04101 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04102 opacity = param0_table[opac_param];
04103 if (param1_size != 0) {
04104 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04105 opacity *= param1_table[opac_param];
04106 if (param2_size != 0) {
04107 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04108 opacity *= param2_table[opac_param];
04109 }
04110 }
04111 if (opacity > min_opacity) {
04112 opacity_int = opacity*255.;
04113 bot_opc = opac_correct[opacity_int];
04114 } else {
04115 bot_opc = (float)0.;
04116 };
04117
04118
04119 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
04120 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
04121
04122
04123
04124 bot_clr =
04125 shade_table[shade_index + 1*0 + 0] *
04126 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04127
04128 bot_sclr =
04129 shadow_table[shade_index + 1*0 + 0] *
04130 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04131 for (m = 1; m < num_materials; m++) {
04132
04133
04134 bot_clr +=
04135 shade_table[shade_index + 1*m + 0] *
04136 weight_table[weight_index + m];
04137
04138 bot_sclr +=
04139 shadow_table[shade_index + 1*m + 0] *
04140 weight_table[weight_index + m];
04141 };
04142 shade_factor = bot_opc * slice_depth_cueing;
04143
04144 bot_clr *= shade_factor;
04145
04146 bot_sclr *= shade_factor;
04147
04148 #ifdef DEBUG
04149 if (ipixel == trace_pixel_ptr) {
04150 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04151 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04152 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04153 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04154 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04155 }
04156 #endif
04157 ;
04158
04159 acc_opc = top_opc * wgtTR;
04160 acc_clr = (top_clr + top_sclr *
04161 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
04162
04163 #ifdef DEBUG
04164 if (ipixel == trace_pixel_ptr) {
04165 trace_opcTR = top_opc;
04166 trace_rclrTR = top_clr;
04167 trace_rsclrTR = top_sclr;
04168 }
04169 #endif
04170 ;
04171
04172 acc_opc += bot_opc * wgtBR;
04173 acc_clr += (bot_clr + bot_sclr *
04174 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
04175
04176 #ifdef DEBUG
04177 if (ipixel == trace_pixel_ptr) {
04178 trace_opcBR = bot_opc;
04179 trace_rclrBR = bot_clr;
04180 trace_rsclrBR = bot_sclr;
04181 }
04182 #endif
04183 ;
04184
04185 COUNT_RESAMPLE;
04186 if (acc_opc > min_opacity) {
04187 COUNT_COMPOSITE;
04188 iopc = ipixel->opcflt;
04189 # ifndef SKIP_ERT
04190 ASSERT(iopc < max_opacity);
04191 # endif
04192 iopc_inv = (float)1. - iopc;
04193 ipixel->clrflt += acc_clr * iopc_inv;
04194 iopc += acc_opc * iopc_inv;
04195 ipixel->opcflt = iopc;
04196
04197 #ifdef DEBUG
04198 if (ipixel == trace_pixel_ptr) {
04199 #ifdef COMPUTE_SHADOW_BUFFER
04200 printf("{%3d} %3d %3d", k, icount-i-count, j);
04201 #else
04202 printf("[%3d] %3d %3d", k, icount-i-count, j);
04203 #endif
04204 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04205 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04206 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04207 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04208 printf(" %3.0f %3.0f\n", iopc*255.,
04209 ipixel->clrflt);
04210
04211 printf(" ");
04212 printf(" %3.0f ",trace_rsclrTL);
04213 printf(" %3.0f ",trace_rsclrBL);
04214 printf(" %3.0f ",trace_rsclrTR);
04215 printf(" %3.0f ",trace_rsclrBR);
04216 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
04217
04218 }
04219 #endif
04220 ;
04221 # ifndef SKIP_ERT
04222 if (iopc >= max_opacity) {
04223 ASSERT(ipixel->lnk == 0);
04224 ipixel->lnk = 1;
04225 }
04226 # endif
04227 };
04228 ipixel += 1; shadow_pixel += 1;
04229 topRLEdata += 1 * voxel_istride;
04230 botRLEdata += 1 * voxel_istride;
04231 count--;
04232 SET_VOXELS_LOADED;
04233
04234
04235
04236 while (count > 0) {
04237 if (PIXEL_IS_OPAQUE(ipixel))
04238 break;
04239 if (!voxels_loaded) {
04240
04241
04242 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04243 opacity = param0_table[opac_param];
04244 if (param1_size != 0) {
04245 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04246 opacity *= param1_table[opac_param];
04247 if (param2_size != 0) {
04248 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04249 opacity *= param2_table[opac_param];
04250 }
04251 }
04252 if (opacity > min_opacity) {
04253 opacity_int = opacity*255.;
04254 top_opc = opac_correct[opacity_int];
04255 } else {
04256 top_opc = (float)0.;
04257 };
04258
04259
04260 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
04261 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
04262
04263
04264
04265 top_clr =
04266 shade_table[shade_index + 1*0 + 0] *
04267 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04268
04269 top_sclr =
04270 shadow_table[shade_index + 1*0 + 0] *
04271 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04272 for (m = 1; m < num_materials; m++) {
04273
04274
04275 top_clr +=
04276 shade_table[shade_index + 1*m + 0] *
04277 weight_table[weight_index + m];
04278
04279 top_sclr +=
04280 shadow_table[shade_index + 1*m + 0] *
04281 weight_table[weight_index + m];
04282 };
04283 shade_factor = top_opc * slice_depth_cueing;
04284
04285 top_clr *= shade_factor;
04286
04287 top_sclr *= shade_factor;
04288
04289
04290 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04291 opacity = param0_table[opac_param];
04292 if (param1_size != 0) {
04293 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04294 opacity *= param1_table[opac_param];
04295 if (param2_size != 0) {
04296 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04297 opacity *= param2_table[opac_param];
04298 }
04299 }
04300 if (opacity > min_opacity) {
04301 opacity_int = opacity*255.;
04302 bot_opc = opac_correct[opacity_int];
04303 } else {
04304 bot_opc = (float)0.;
04305 };
04306
04307
04308 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
04309 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
04310
04311
04312
04313 bot_clr =
04314 shade_table[shade_index + 1*0 + 0] *
04315 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04316
04317 bot_sclr =
04318 shadow_table[shade_index + 1*0 + 0] *
04319 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04320 for (m = 1; m < num_materials; m++) {
04321
04322
04323 bot_clr +=
04324 shade_table[shade_index + 1*m + 0] *
04325 weight_table[weight_index + m];
04326
04327 bot_sclr +=
04328 shadow_table[shade_index + 1*m + 0] *
04329 weight_table[weight_index + m];
04330 };
04331 shade_factor = bot_opc * slice_depth_cueing;
04332
04333 bot_clr *= shade_factor;
04334
04335 bot_sclr *= shade_factor;
04336 }
04337
04338 #ifdef DEBUG
04339 if (ipixel == trace_pixel_ptr) {
04340 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04341 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04342 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04343 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04344 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04345 }
04346 #endif
04347 ;
04348
04349 acc_opc = top_opc * wgtTL;
04350 acc_clr = (top_clr + top_sclr *
04351 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
04352
04353 #ifdef DEBUG
04354 if (ipixel == trace_pixel_ptr) {
04355 trace_opcTL = top_opc;
04356 trace_rclrTL = top_clr;
04357 trace_rsclrTL = top_sclr;
04358 }
04359 #endif
04360 ;
04361
04362 acc_opc += bot_opc * wgtBL;
04363 acc_clr += (bot_clr + bot_sclr *
04364 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
04365
04366 #ifdef DEBUG
04367 if (ipixel == trace_pixel_ptr) {
04368 trace_opcBL = bot_opc;
04369 trace_rclrBL = bot_clr;
04370 trace_rsclrBL = bot_sclr;
04371 }
04372 #endif
04373 ;
04374
04375
04376 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04377 opacity = param0_table[opac_param];
04378 if (param1_size != 0) {
04379 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04380 opacity *= param1_table[opac_param];
04381 if (param2_size != 0) {
04382 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04383 opacity *= param2_table[opac_param];
04384 }
04385 }
04386 if (opacity > min_opacity) {
04387 opacity_int = opacity*255.;
04388 top_opc = opac_correct[opacity_int];
04389 } else {
04390 top_opc = (float)0.;
04391 };
04392
04393
04394 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
04395 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
04396
04397
04398
04399 top_clr =
04400 shade_table[shade_index + 1*0 + 0] *
04401 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04402
04403 top_sclr =
04404 shadow_table[shade_index + 1*0 + 0] *
04405 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04406 for (m = 1; m < num_materials; m++) {
04407
04408
04409 top_clr +=
04410 shade_table[shade_index + 1*m + 0] *
04411 weight_table[weight_index + m];
04412
04413 top_sclr +=
04414 shadow_table[shade_index + 1*m + 0] *
04415 weight_table[weight_index + m];
04416 };
04417 shade_factor = top_opc * slice_depth_cueing;
04418
04419 top_clr *= shade_factor;
04420
04421 top_sclr *= shade_factor;
04422
04423
04424 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04425 opacity = param0_table[opac_param];
04426 if (param1_size != 0) {
04427 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04428 opacity *= param1_table[opac_param];
04429 if (param2_size != 0) {
04430 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04431 opacity *= param2_table[opac_param];
04432 }
04433 }
04434 if (opacity > min_opacity) {
04435 opacity_int = opacity*255.;
04436 bot_opc = opac_correct[opacity_int];
04437 } else {
04438 bot_opc = (float)0.;
04439 };
04440
04441
04442 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
04443 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
04444
04445
04446
04447 bot_clr =
04448 shade_table[shade_index + 1*0 + 0] *
04449 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04450
04451 bot_sclr =
04452 shadow_table[shade_index + 1*0 + 0] *
04453 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04454 for (m = 1; m < num_materials; m++) {
04455
04456
04457 bot_clr +=
04458 shade_table[shade_index + 1*m + 0] *
04459 weight_table[weight_index + m];
04460
04461 bot_sclr +=
04462 shadow_table[shade_index + 1*m + 0] *
04463 weight_table[weight_index + m];
04464 };
04465 shade_factor = bot_opc * slice_depth_cueing;
04466
04467 bot_clr *= shade_factor;
04468
04469 bot_sclr *= shade_factor;
04470
04471 acc_opc += top_opc * wgtTR;
04472 acc_clr += (top_clr + top_sclr *
04473 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
04474
04475 #ifdef DEBUG
04476 if (ipixel == trace_pixel_ptr) {
04477 trace_opcTR = top_opc;
04478 trace_rclrTR = top_clr;
04479 trace_rsclrTR = top_sclr;
04480 }
04481 #endif
04482 ;
04483
04484 acc_opc += bot_opc * wgtBR;
04485 acc_clr += (bot_clr + bot_sclr *
04486 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
04487
04488 #ifdef DEBUG
04489 if (ipixel == trace_pixel_ptr) {
04490 trace_opcBR = bot_opc;
04491 trace_rclrBR = bot_clr;
04492 trace_rsclrBR = bot_sclr;
04493 }
04494 #endif
04495 ;
04496
04497 COUNT_RESAMPLE;
04498 if (acc_opc > min_opacity) {
04499 COUNT_COMPOSITE;
04500 iopc = ipixel->opcflt;
04501 # ifndef SKIP_ERT
04502 ASSERT(iopc < max_opacity);
04503 # endif
04504 iopc_inv = (float)1. - iopc;
04505 ipixel->clrflt += acc_clr * iopc_inv;
04506 iopc += acc_opc * iopc_inv;
04507 ipixel->opcflt = iopc;
04508
04509 #ifdef DEBUG
04510 if (ipixel == trace_pixel_ptr) {
04511 #ifdef COMPUTE_SHADOW_BUFFER
04512 printf("{%3d} %3d %3d", k, icount-i-count, j);
04513 #else
04514 printf("[%3d] %3d %3d", k, icount-i-count, j);
04515 #endif
04516 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04517 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04518 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04519 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04520 printf(" %3.0f %3.0f\n", iopc*255.,
04521 ipixel->clrflt);
04522
04523 printf(" ");
04524 printf(" %3.0f ",trace_rsclrTL);
04525 printf(" %3.0f ",trace_rsclrBL);
04526 printf(" %3.0f ",trace_rsclrTR);
04527 printf(" %3.0f ",trace_rsclrBR);
04528 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
04529
04530 }
04531 #endif
04532 ;
04533 # ifndef SKIP_ERT
04534 if (iopc >= max_opacity) {
04535 ASSERT(ipixel->lnk == 0);
04536 ipixel->lnk = 1;
04537 }
04538 # endif
04539 };
04540 ipixel += 1; shadow_pixel += 1;
04541 topRLEdata += 1 * voxel_istride;
04542 botRLEdata += 1 * voxel_istride;
04543 count--;
04544 SET_VOXELS_LOADED;
04545 }
04546 break;
04547 case TOP_NONZERO__ALL_NONZERO:
04548
04549
04550 if (!voxels_loaded) {
04551
04552
04553 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04554 opacity = param0_table[opac_param];
04555 if (param1_size != 0) {
04556 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04557 opacity *= param1_table[opac_param];
04558 if (param2_size != 0) {
04559 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04560 opacity *= param2_table[opac_param];
04561 }
04562 }
04563 if (opacity > min_opacity) {
04564 opacity_int = opacity*255.;
04565 top_opc = opac_correct[opacity_int];
04566 } else {
04567 top_opc = (float)0.;
04568 };
04569
04570
04571 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
04572 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
04573
04574
04575
04576 top_clr =
04577 shade_table[shade_index + 1*0 + 0] *
04578 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04579
04580 top_sclr =
04581 shadow_table[shade_index + 1*0 + 0] *
04582 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04583 for (m = 1; m < num_materials; m++) {
04584
04585
04586 top_clr +=
04587 shade_table[shade_index + 1*m + 0] *
04588 weight_table[weight_index + m];
04589
04590 top_sclr +=
04591 shadow_table[shade_index + 1*m + 0] *
04592 weight_table[weight_index + m];
04593 };
04594 shade_factor = top_opc * slice_depth_cueing;
04595
04596 top_clr *= shade_factor;
04597
04598 top_sclr *= shade_factor;
04599 }
04600
04601 #ifdef DEBUG
04602 if (ipixel == trace_pixel_ptr) {
04603 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04604 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04605 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04606 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04607 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04608 }
04609 #endif
04610 ;
04611
04612 acc_opc = top_opc * wgtTL;
04613 acc_clr = (top_clr + top_sclr *
04614 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
04615
04616 #ifdef DEBUG
04617 if (ipixel == trace_pixel_ptr) {
04618 trace_opcTL = top_opc;
04619 trace_rclrTL = top_clr;
04620 trace_rsclrTL = top_sclr;
04621 }
04622 #endif
04623 ;
04624
04625
04626 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04627 opacity = param0_table[opac_param];
04628 if (param1_size != 0) {
04629 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04630 opacity *= param1_table[opac_param];
04631 if (param2_size != 0) {
04632 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04633 opacity *= param2_table[opac_param];
04634 }
04635 }
04636 if (opacity > min_opacity) {
04637 opacity_int = opacity*255.;
04638 top_opc = opac_correct[opacity_int];
04639 } else {
04640 top_opc = (float)0.;
04641 };
04642
04643
04644 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
04645 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
04646
04647
04648
04649 top_clr =
04650 shade_table[shade_index + 1*0 + 0] *
04651 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04652
04653 top_sclr =
04654 shadow_table[shade_index + 1*0 + 0] *
04655 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04656 for (m = 1; m < num_materials; m++) {
04657
04658
04659 top_clr +=
04660 shade_table[shade_index + 1*m + 0] *
04661 weight_table[weight_index + m];
04662
04663 top_sclr +=
04664 shadow_table[shade_index + 1*m + 0] *
04665 weight_table[weight_index + m];
04666 };
04667 shade_factor = top_opc * slice_depth_cueing;
04668
04669 top_clr *= shade_factor;
04670
04671 top_sclr *= shade_factor;
04672
04673
04674 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04675 opacity = param0_table[opac_param];
04676 if (param1_size != 0) {
04677 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04678 opacity *= param1_table[opac_param];
04679 if (param2_size != 0) {
04680 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04681 opacity *= param2_table[opac_param];
04682 }
04683 }
04684 if (opacity > min_opacity) {
04685 opacity_int = opacity*255.;
04686 bot_opc = opac_correct[opacity_int];
04687 } else {
04688 bot_opc = (float)0.;
04689 };
04690
04691
04692 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
04693 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
04694
04695
04696
04697 bot_clr =
04698 shade_table[shade_index + 1*0 + 0] *
04699 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04700
04701 bot_sclr =
04702 shadow_table[shade_index + 1*0 + 0] *
04703 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04704 for (m = 1; m < num_materials; m++) {
04705
04706
04707 bot_clr +=
04708 shade_table[shade_index + 1*m + 0] *
04709 weight_table[weight_index + m];
04710
04711 bot_sclr +=
04712 shadow_table[shade_index + 1*m + 0] *
04713 weight_table[weight_index + m];
04714 };
04715 shade_factor = bot_opc * slice_depth_cueing;
04716
04717 bot_clr *= shade_factor;
04718
04719 bot_sclr *= shade_factor;
04720
04721 acc_opc += top_opc * wgtTR;
04722 acc_clr += (top_clr + top_sclr *
04723 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
04724
04725 #ifdef DEBUG
04726 if (ipixel == trace_pixel_ptr) {
04727 trace_opcTR = top_opc;
04728 trace_rclrTR = top_clr;
04729 trace_rsclrTR = top_sclr;
04730 }
04731 #endif
04732 ;
04733
04734 acc_opc += bot_opc * wgtBR;
04735 acc_clr += (bot_clr + bot_sclr *
04736 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
04737
04738 #ifdef DEBUG
04739 if (ipixel == trace_pixel_ptr) {
04740 trace_opcBR = bot_opc;
04741 trace_rclrBR = bot_clr;
04742 trace_rsclrBR = bot_sclr;
04743 }
04744 #endif
04745 ;
04746
04747 COUNT_RESAMPLE;
04748 if (acc_opc > min_opacity) {
04749 COUNT_COMPOSITE;
04750 iopc = ipixel->opcflt;
04751 # ifndef SKIP_ERT
04752 ASSERT(iopc < max_opacity);
04753 # endif
04754 iopc_inv = (float)1. - iopc;
04755 ipixel->clrflt += acc_clr * iopc_inv;
04756 iopc += acc_opc * iopc_inv;
04757 ipixel->opcflt = iopc;
04758
04759 #ifdef DEBUG
04760 if (ipixel == trace_pixel_ptr) {
04761 #ifdef COMPUTE_SHADOW_BUFFER
04762 printf("{%3d} %3d %3d", k, icount-i-count, j);
04763 #else
04764 printf("[%3d] %3d %3d", k, icount-i-count, j);
04765 #endif
04766 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
04767 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
04768 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
04769 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
04770 printf(" %3.0f %3.0f\n", iopc*255.,
04771 ipixel->clrflt);
04772
04773 printf(" ");
04774 printf(" %3.0f ",trace_rsclrTL);
04775 printf(" %3.0f ",trace_rsclrBL);
04776 printf(" %3.0f ",trace_rsclrTR);
04777 printf(" %3.0f ",trace_rsclrBR);
04778 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
04779
04780 }
04781 #endif
04782 ;
04783 # ifndef SKIP_ERT
04784 if (iopc >= max_opacity) {
04785 ASSERT(ipixel->lnk == 0);
04786 ipixel->lnk = 1;
04787 }
04788 # endif
04789 };
04790 ipixel += 1; shadow_pixel += 1;
04791 topRLEdata += 1 * voxel_istride;
04792 botRLEdata += 1 * voxel_istride;
04793 count--;
04794 SET_VOXELS_LOADED;
04795
04796
04797
04798 while (count > 0) {
04799 if (PIXEL_IS_OPAQUE(ipixel))
04800 break;
04801 if (!voxels_loaded) {
04802
04803
04804 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
04805 opacity = param0_table[opac_param];
04806 if (param1_size != 0) {
04807 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
04808 opacity *= param1_table[opac_param];
04809 if (param2_size != 0) {
04810 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
04811 opacity *= param2_table[opac_param];
04812 }
04813 }
04814 if (opacity > min_opacity) {
04815 opacity_int = opacity*255.;
04816 top_opc = opac_correct[opacity_int];
04817 } else {
04818 top_opc = (float)0.;
04819 };
04820
04821
04822 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
04823 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
04824
04825
04826
04827 top_clr =
04828 shade_table[shade_index + 1*0 + 0] *
04829 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04830
04831 top_sclr =
04832 shadow_table[shade_index + 1*0 + 0] *
04833 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04834 for (m = 1; m < num_materials; m++) {
04835
04836
04837 top_clr +=
04838 shade_table[shade_index + 1*m + 0] *
04839 weight_table[weight_index + m];
04840
04841 top_sclr +=
04842 shadow_table[shade_index + 1*m + 0] *
04843 weight_table[weight_index + m];
04844 };
04845 shade_factor = top_opc * slice_depth_cueing;
04846
04847 top_clr *= shade_factor;
04848
04849 top_sclr *= shade_factor;
04850
04851
04852 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
04853 opacity = param0_table[opac_param];
04854 if (param1_size != 0) {
04855 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
04856 opacity *= param1_table[opac_param];
04857 if (param2_size != 0) {
04858 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
04859 opacity *= param2_table[opac_param];
04860 }
04861 }
04862 if (opacity > min_opacity) {
04863 opacity_int = opacity*255.;
04864 bot_opc = opac_correct[opacity_int];
04865 } else {
04866 bot_opc = (float)0.;
04867 };
04868
04869
04870 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
04871 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
04872
04873
04874
04875 bot_clr =
04876 shade_table[shade_index + 1*0 + 0] *
04877 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04878
04879 bot_sclr =
04880 shadow_table[shade_index + 1*0 + 0] *
04881 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04882 for (m = 1; m < num_materials; m++) {
04883
04884
04885 bot_clr +=
04886 shade_table[shade_index + 1*m + 0] *
04887 weight_table[weight_index + m];
04888
04889 bot_sclr +=
04890 shadow_table[shade_index + 1*m + 0] *
04891 weight_table[weight_index + m];
04892 };
04893 shade_factor = bot_opc * slice_depth_cueing;
04894
04895 bot_clr *= shade_factor;
04896
04897 bot_sclr *= shade_factor;
04898 }
04899
04900 #ifdef DEBUG
04901 if (ipixel == trace_pixel_ptr) {
04902 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
04903 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
04904 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
04905 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
04906 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
04907 }
04908 #endif
04909 ;
04910
04911 acc_opc = top_opc * wgtTL;
04912 acc_clr = (top_clr + top_sclr *
04913 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
04914
04915 #ifdef DEBUG
04916 if (ipixel == trace_pixel_ptr) {
04917 trace_opcTL = top_opc;
04918 trace_rclrTL = top_clr;
04919 trace_rsclrTL = top_sclr;
04920 }
04921 #endif
04922 ;
04923
04924 acc_opc += bot_opc * wgtBL;
04925 acc_clr += (bot_clr + bot_sclr *
04926 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
04927
04928 #ifdef DEBUG
04929 if (ipixel == trace_pixel_ptr) {
04930 trace_opcBL = bot_opc;
04931 trace_rclrBL = bot_clr;
04932 trace_rsclrBL = bot_sclr;
04933 }
04934 #endif
04935 ;
04936
04937
04938 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
04939 opacity = param0_table[opac_param];
04940 if (param1_size != 0) {
04941 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
04942 opacity *= param1_table[opac_param];
04943 if (param2_size != 0) {
04944 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
04945 opacity *= param2_table[opac_param];
04946 }
04947 }
04948 if (opacity > min_opacity) {
04949 opacity_int = opacity*255.;
04950 top_opc = opac_correct[opacity_int];
04951 } else {
04952 top_opc = (float)0.;
04953 };
04954
04955
04956 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
04957 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
04958
04959
04960
04961 top_clr =
04962 shade_table[shade_index + 1*0 + 0] *
04963 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04964
04965 top_sclr =
04966 shadow_table[shade_index + 1*0 + 0] *
04967 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
04968 for (m = 1; m < num_materials; m++) {
04969
04970
04971 top_clr +=
04972 shade_table[shade_index + 1*m + 0] *
04973 weight_table[weight_index + m];
04974
04975 top_sclr +=
04976 shadow_table[shade_index + 1*m + 0] *
04977 weight_table[weight_index + m];
04978 };
04979 shade_factor = top_opc * slice_depth_cueing;
04980
04981 top_clr *= shade_factor;
04982
04983 top_sclr *= shade_factor;
04984
04985
04986 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
04987 opacity = param0_table[opac_param];
04988 if (param1_size != 0) {
04989 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
04990 opacity *= param1_table[opac_param];
04991 if (param2_size != 0) {
04992 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
04993 opacity *= param2_table[opac_param];
04994 }
04995 }
04996 if (opacity > min_opacity) {
04997 opacity_int = opacity*255.;
04998 bot_opc = opac_correct[opacity_int];
04999 } else {
05000 bot_opc = (float)0.;
05001 };
05002
05003
05004 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
05005 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
05006
05007
05008
05009 bot_clr =
05010 shade_table[shade_index + 1*0 + 0] *
05011 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05012
05013 bot_sclr =
05014 shadow_table[shade_index + 1*0 + 0] *
05015 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05016 for (m = 1; m < num_materials; m++) {
05017
05018
05019 bot_clr +=
05020 shade_table[shade_index + 1*m + 0] *
05021 weight_table[weight_index + m];
05022
05023 bot_sclr +=
05024 shadow_table[shade_index + 1*m + 0] *
05025 weight_table[weight_index + m];
05026 };
05027 shade_factor = bot_opc * slice_depth_cueing;
05028
05029 bot_clr *= shade_factor;
05030
05031 bot_sclr *= shade_factor;
05032
05033 acc_opc += top_opc * wgtTR;
05034 acc_clr += (top_clr + top_sclr *
05035 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
05036
05037 #ifdef DEBUG
05038 if (ipixel == trace_pixel_ptr) {
05039 trace_opcTR = top_opc;
05040 trace_rclrTR = top_clr;
05041 trace_rsclrTR = top_sclr;
05042 }
05043 #endif
05044 ;
05045
05046 acc_opc += bot_opc * wgtBR;
05047 acc_clr += (bot_clr + bot_sclr *
05048 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
05049
05050 #ifdef DEBUG
05051 if (ipixel == trace_pixel_ptr) {
05052 trace_opcBR = bot_opc;
05053 trace_rclrBR = bot_clr;
05054 trace_rsclrBR = bot_sclr;
05055 }
05056 #endif
05057 ;
05058
05059 COUNT_RESAMPLE;
05060 if (acc_opc > min_opacity) {
05061 COUNT_COMPOSITE;
05062 iopc = ipixel->opcflt;
05063 # ifndef SKIP_ERT
05064 ASSERT(iopc < max_opacity);
05065 # endif
05066 iopc_inv = (float)1. - iopc;
05067 ipixel->clrflt += acc_clr * iopc_inv;
05068 iopc += acc_opc * iopc_inv;
05069 ipixel->opcflt = iopc;
05070
05071 #ifdef DEBUG
05072 if (ipixel == trace_pixel_ptr) {
05073 #ifdef COMPUTE_SHADOW_BUFFER
05074 printf("{%3d} %3d %3d", k, icount-i-count, j);
05075 #else
05076 printf("[%3d] %3d %3d", k, icount-i-count, j);
05077 #endif
05078 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
05079 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
05080 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
05081 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
05082 printf(" %3.0f %3.0f\n", iopc*255.,
05083 ipixel->clrflt);
05084
05085 printf(" ");
05086 printf(" %3.0f ",trace_rsclrTL);
05087 printf(" %3.0f ",trace_rsclrBL);
05088 printf(" %3.0f ",trace_rsclrTR);
05089 printf(" %3.0f ",trace_rsclrBR);
05090 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
05091
05092 }
05093 #endif
05094 ;
05095 # ifndef SKIP_ERT
05096 if (iopc >= max_opacity) {
05097 ASSERT(ipixel->lnk == 0);
05098 ipixel->lnk = 1;
05099 }
05100 # endif
05101 };
05102 ipixel += 1; shadow_pixel += 1;
05103 topRLEdata += 1 * voxel_istride;
05104 botRLEdata += 1 * voxel_istride;
05105 count--;
05106 SET_VOXELS_LOADED;
05107 }
05108 break;
05109 case BOT_NONZERO__ALL_NONZERO:
05110
05111
05112 if (!voxels_loaded) {
05113
05114
05115 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
05116 opacity = param0_table[opac_param];
05117 if (param1_size != 0) {
05118 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
05119 opacity *= param1_table[opac_param];
05120 if (param2_size != 0) {
05121 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
05122 opacity *= param2_table[opac_param];
05123 }
05124 }
05125 if (opacity > min_opacity) {
05126 opacity_int = opacity*255.;
05127 bot_opc = opac_correct[opacity_int];
05128 } else {
05129 bot_opc = (float)0.;
05130 };
05131
05132
05133 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
05134 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
05135
05136
05137
05138 bot_clr =
05139 shade_table[shade_index + 1*0 + 0] *
05140 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05141
05142 bot_sclr =
05143 shadow_table[shade_index + 1*0 + 0] *
05144 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05145 for (m = 1; m < num_materials; m++) {
05146
05147
05148 bot_clr +=
05149 shade_table[shade_index + 1*m + 0] *
05150 weight_table[weight_index + m];
05151
05152 bot_sclr +=
05153 shadow_table[shade_index + 1*m + 0] *
05154 weight_table[weight_index + m];
05155 };
05156 shade_factor = bot_opc * slice_depth_cueing;
05157
05158 bot_clr *= shade_factor;
05159
05160 bot_sclr *= shade_factor;
05161 }
05162
05163 #ifdef DEBUG
05164 if (ipixel == trace_pixel_ptr) {
05165 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
05166 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
05167 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
05168 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
05169 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
05170 }
05171 #endif
05172 ;
05173
05174 acc_opc = bot_opc * wgtBL;
05175 acc_clr = (bot_clr + bot_sclr *
05176 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
05177
05178 #ifdef DEBUG
05179 if (ipixel == trace_pixel_ptr) {
05180 trace_opcBL = bot_opc;
05181 trace_rclrBL = bot_clr;
05182 trace_rsclrBL = bot_sclr;
05183 }
05184 #endif
05185 ;
05186
05187
05188 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
05189 opacity = param0_table[opac_param];
05190 if (param1_size != 0) {
05191 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
05192 opacity *= param1_table[opac_param];
05193 if (param2_size != 0) {
05194 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
05195 opacity *= param2_table[opac_param];
05196 }
05197 }
05198 if (opacity > min_opacity) {
05199 opacity_int = opacity*255.;
05200 top_opc = opac_correct[opacity_int];
05201 } else {
05202 top_opc = (float)0.;
05203 };
05204
05205
05206 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
05207 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
05208
05209
05210
05211 top_clr =
05212 shade_table[shade_index + 1*0 + 0] *
05213 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05214
05215 top_sclr =
05216 shadow_table[shade_index + 1*0 + 0] *
05217 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05218 for (m = 1; m < num_materials; m++) {
05219
05220
05221 top_clr +=
05222 shade_table[shade_index + 1*m + 0] *
05223 weight_table[weight_index + m];
05224
05225 top_sclr +=
05226 shadow_table[shade_index + 1*m + 0] *
05227 weight_table[weight_index + m];
05228 };
05229 shade_factor = top_opc * slice_depth_cueing;
05230
05231 top_clr *= shade_factor;
05232
05233 top_sclr *= shade_factor;
05234
05235
05236 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
05237 opacity = param0_table[opac_param];
05238 if (param1_size != 0) {
05239 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
05240 opacity *= param1_table[opac_param];
05241 if (param2_size != 0) {
05242 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
05243 opacity *= param2_table[opac_param];
05244 }
05245 }
05246 if (opacity > min_opacity) {
05247 opacity_int = opacity*255.;
05248 bot_opc = opac_correct[opacity_int];
05249 } else {
05250 bot_opc = (float)0.;
05251 };
05252
05253
05254 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
05255 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
05256
05257
05258
05259 bot_clr =
05260 shade_table[shade_index + 1*0 + 0] *
05261 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05262
05263 bot_sclr =
05264 shadow_table[shade_index + 1*0 + 0] *
05265 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05266 for (m = 1; m < num_materials; m++) {
05267
05268
05269 bot_clr +=
05270 shade_table[shade_index + 1*m + 0] *
05271 weight_table[weight_index + m];
05272
05273 bot_sclr +=
05274 shadow_table[shade_index + 1*m + 0] *
05275 weight_table[weight_index + m];
05276 };
05277 shade_factor = bot_opc * slice_depth_cueing;
05278
05279 bot_clr *= shade_factor;
05280
05281 bot_sclr *= shade_factor;
05282
05283 acc_opc += top_opc * wgtTR;
05284 acc_clr += (top_clr + top_sclr *
05285 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
05286
05287 #ifdef DEBUG
05288 if (ipixel == trace_pixel_ptr) {
05289 trace_opcTR = top_opc;
05290 trace_rclrTR = top_clr;
05291 trace_rsclrTR = top_sclr;
05292 }
05293 #endif
05294 ;
05295
05296 acc_opc += bot_opc * wgtBR;
05297 acc_clr += (bot_clr + bot_sclr *
05298 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
05299
05300 #ifdef DEBUG
05301 if (ipixel == trace_pixel_ptr) {
05302 trace_opcBR = bot_opc;
05303 trace_rclrBR = bot_clr;
05304 trace_rsclrBR = bot_sclr;
05305 }
05306 #endif
05307 ;
05308
05309 COUNT_RESAMPLE;
05310 if (acc_opc > min_opacity) {
05311 COUNT_COMPOSITE;
05312 iopc = ipixel->opcflt;
05313 # ifndef SKIP_ERT
05314 ASSERT(iopc < max_opacity);
05315 # endif
05316 iopc_inv = (float)1. - iopc;
05317 ipixel->clrflt += acc_clr * iopc_inv;
05318 iopc += acc_opc * iopc_inv;
05319 ipixel->opcflt = iopc;
05320
05321 #ifdef DEBUG
05322 if (ipixel == trace_pixel_ptr) {
05323 #ifdef COMPUTE_SHADOW_BUFFER
05324 printf("{%3d} %3d %3d", k, icount-i-count, j);
05325 #else
05326 printf("[%3d] %3d %3d", k, icount-i-count, j);
05327 #endif
05328 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
05329 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
05330 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
05331 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
05332 printf(" %3.0f %3.0f\n", iopc*255.,
05333 ipixel->clrflt);
05334
05335 printf(" ");
05336 printf(" %3.0f ",trace_rsclrTL);
05337 printf(" %3.0f ",trace_rsclrBL);
05338 printf(" %3.0f ",trace_rsclrTR);
05339 printf(" %3.0f ",trace_rsclrBR);
05340 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
05341
05342 }
05343 #endif
05344 ;
05345 # ifndef SKIP_ERT
05346 if (iopc >= max_opacity) {
05347 ASSERT(ipixel->lnk == 0);
05348 ipixel->lnk = 1;
05349 }
05350 # endif
05351 };
05352 ipixel += 1; shadow_pixel += 1;
05353 topRLEdata += 1 * voxel_istride;
05354 botRLEdata += 1 * voxel_istride;
05355 count--;
05356 SET_VOXELS_LOADED;
05357
05358
05359
05360 while (count > 0) {
05361 if (PIXEL_IS_OPAQUE(ipixel))
05362 break;
05363 if (!voxels_loaded) {
05364
05365
05366 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
05367 opacity = param0_table[opac_param];
05368 if (param1_size != 0) {
05369 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
05370 opacity *= param1_table[opac_param];
05371 if (param2_size != 0) {
05372 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
05373 opacity *= param2_table[opac_param];
05374 }
05375 }
05376 if (opacity > min_opacity) {
05377 opacity_int = opacity*255.;
05378 top_opc = opac_correct[opacity_int];
05379 } else {
05380 top_opc = (float)0.;
05381 };
05382
05383
05384 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
05385 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
05386
05387
05388
05389 top_clr =
05390 shade_table[shade_index + 1*0 + 0] *
05391 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05392
05393 top_sclr =
05394 shadow_table[shade_index + 1*0 + 0] *
05395 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05396 for (m = 1; m < num_materials; m++) {
05397
05398
05399 top_clr +=
05400 shade_table[shade_index + 1*m + 0] *
05401 weight_table[weight_index + m];
05402
05403 top_sclr +=
05404 shadow_table[shade_index + 1*m + 0] *
05405 weight_table[weight_index + m];
05406 };
05407 shade_factor = top_opc * slice_depth_cueing;
05408
05409 top_clr *= shade_factor;
05410
05411 top_sclr *= shade_factor;
05412
05413
05414 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
05415 opacity = param0_table[opac_param];
05416 if (param1_size != 0) {
05417 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
05418 opacity *= param1_table[opac_param];
05419 if (param2_size != 0) {
05420 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
05421 opacity *= param2_table[opac_param];
05422 }
05423 }
05424 if (opacity > min_opacity) {
05425 opacity_int = opacity*255.;
05426 bot_opc = opac_correct[opacity_int];
05427 } else {
05428 bot_opc = (float)0.;
05429 };
05430
05431
05432 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
05433 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
05434
05435
05436
05437 bot_clr =
05438 shade_table[shade_index + 1*0 + 0] *
05439 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05440
05441 bot_sclr =
05442 shadow_table[shade_index + 1*0 + 0] *
05443 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05444 for (m = 1; m < num_materials; m++) {
05445
05446
05447 bot_clr +=
05448 shade_table[shade_index + 1*m + 0] *
05449 weight_table[weight_index + m];
05450
05451 bot_sclr +=
05452 shadow_table[shade_index + 1*m + 0] *
05453 weight_table[weight_index + m];
05454 };
05455 shade_factor = bot_opc * slice_depth_cueing;
05456
05457 bot_clr *= shade_factor;
05458
05459 bot_sclr *= shade_factor;
05460 }
05461
05462 #ifdef DEBUG
05463 if (ipixel == trace_pixel_ptr) {
05464 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
05465 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
05466 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
05467 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
05468 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
05469 }
05470 #endif
05471 ;
05472
05473 acc_opc = top_opc * wgtTL;
05474 acc_clr = (top_clr + top_sclr *
05475 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
05476
05477 #ifdef DEBUG
05478 if (ipixel == trace_pixel_ptr) {
05479 trace_opcTL = top_opc;
05480 trace_rclrTL = top_clr;
05481 trace_rsclrTL = top_sclr;
05482 }
05483 #endif
05484 ;
05485
05486 acc_opc += bot_opc * wgtBL;
05487 acc_clr += (bot_clr + bot_sclr *
05488 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
05489
05490 #ifdef DEBUG
05491 if (ipixel == trace_pixel_ptr) {
05492 trace_opcBL = bot_opc;
05493 trace_rclrBL = bot_clr;
05494 trace_rsclrBL = bot_sclr;
05495 }
05496 #endif
05497 ;
05498
05499
05500 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
05501 opacity = param0_table[opac_param];
05502 if (param1_size != 0) {
05503 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
05504 opacity *= param1_table[opac_param];
05505 if (param2_size != 0) {
05506 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
05507 opacity *= param2_table[opac_param];
05508 }
05509 }
05510 if (opacity > min_opacity) {
05511 opacity_int = opacity*255.;
05512 top_opc = opac_correct[opacity_int];
05513 } else {
05514 top_opc = (float)0.;
05515 };
05516
05517
05518 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
05519 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
05520
05521
05522
05523 top_clr =
05524 shade_table[shade_index + 1*0 + 0] *
05525 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05526
05527 top_sclr =
05528 shadow_table[shade_index + 1*0 + 0] *
05529 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05530 for (m = 1; m < num_materials; m++) {
05531
05532
05533 top_clr +=
05534 shade_table[shade_index + 1*m + 0] *
05535 weight_table[weight_index + m];
05536
05537 top_sclr +=
05538 shadow_table[shade_index + 1*m + 0] *
05539 weight_table[weight_index + m];
05540 };
05541 shade_factor = top_opc * slice_depth_cueing;
05542
05543 top_clr *= shade_factor;
05544
05545 top_sclr *= shade_factor;
05546
05547
05548 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
05549 opacity = param0_table[opac_param];
05550 if (param1_size != 0) {
05551 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
05552 opacity *= param1_table[opac_param];
05553 if (param2_size != 0) {
05554 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
05555 opacity *= param2_table[opac_param];
05556 }
05557 }
05558 if (opacity > min_opacity) {
05559 opacity_int = opacity*255.;
05560 bot_opc = opac_correct[opacity_int];
05561 } else {
05562 bot_opc = (float)0.;
05563 };
05564
05565
05566 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
05567 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
05568
05569
05570
05571 bot_clr =
05572 shade_table[shade_index + 1*0 + 0] *
05573 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05574
05575 bot_sclr =
05576 shadow_table[shade_index + 1*0 + 0] *
05577 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05578 for (m = 1; m < num_materials; m++) {
05579
05580
05581 bot_clr +=
05582 shade_table[shade_index + 1*m + 0] *
05583 weight_table[weight_index + m];
05584
05585 bot_sclr +=
05586 shadow_table[shade_index + 1*m + 0] *
05587 weight_table[weight_index + m];
05588 };
05589 shade_factor = bot_opc * slice_depth_cueing;
05590
05591 bot_clr *= shade_factor;
05592
05593 bot_sclr *= shade_factor;
05594
05595 acc_opc += top_opc * wgtTR;
05596 acc_clr += (top_clr + top_sclr *
05597 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
05598
05599 #ifdef DEBUG
05600 if (ipixel == trace_pixel_ptr) {
05601 trace_opcTR = top_opc;
05602 trace_rclrTR = top_clr;
05603 trace_rsclrTR = top_sclr;
05604 }
05605 #endif
05606 ;
05607
05608 acc_opc += bot_opc * wgtBR;
05609 acc_clr += (bot_clr + bot_sclr *
05610 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
05611
05612 #ifdef DEBUG
05613 if (ipixel == trace_pixel_ptr) {
05614 trace_opcBR = bot_opc;
05615 trace_rclrBR = bot_clr;
05616 trace_rsclrBR = bot_sclr;
05617 }
05618 #endif
05619 ;
05620
05621 COUNT_RESAMPLE;
05622 if (acc_opc > min_opacity) {
05623 COUNT_COMPOSITE;
05624 iopc = ipixel->opcflt;
05625 # ifndef SKIP_ERT
05626 ASSERT(iopc < max_opacity);
05627 # endif
05628 iopc_inv = (float)1. - iopc;
05629 ipixel->clrflt += acc_clr * iopc_inv;
05630 iopc += acc_opc * iopc_inv;
05631 ipixel->opcflt = iopc;
05632
05633 #ifdef DEBUG
05634 if (ipixel == trace_pixel_ptr) {
05635 #ifdef COMPUTE_SHADOW_BUFFER
05636 printf("{%3d} %3d %3d", k, icount-i-count, j);
05637 #else
05638 printf("[%3d] %3d %3d", k, icount-i-count, j);
05639 #endif
05640 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
05641 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
05642 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
05643 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
05644 printf(" %3.0f %3.0f\n", iopc*255.,
05645 ipixel->clrflt);
05646
05647 printf(" ");
05648 printf(" %3.0f ",trace_rsclrTL);
05649 printf(" %3.0f ",trace_rsclrBL);
05650 printf(" %3.0f ",trace_rsclrTR);
05651 printf(" %3.0f ",trace_rsclrBR);
05652 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
05653
05654 }
05655 #endif
05656 ;
05657 # ifndef SKIP_ERT
05658 if (iopc >= max_opacity) {
05659 ASSERT(ipixel->lnk == 0);
05660 ipixel->lnk = 1;
05661 }
05662 # endif
05663 };
05664 ipixel += 1; shadow_pixel += 1;
05665 topRLEdata += 1 * voxel_istride;
05666 botRLEdata += 1 * voxel_istride;
05667 count--;
05668 SET_VOXELS_LOADED;
05669 }
05670 break;
05671 case ALL_NONZERO__ALL_NONZERO:
05672
05673 while (count > 0) {
05674 if (PIXEL_IS_OPAQUE(ipixel))
05675 break;
05676 if (!voxels_loaded) {
05677
05678
05679 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
05680 opacity = param0_table[opac_param];
05681 if (param1_size != 0) {
05682 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
05683 opacity *= param1_table[opac_param];
05684 if (param2_size != 0) {
05685 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
05686 opacity *= param2_table[opac_param];
05687 }
05688 }
05689 if (opacity > min_opacity) {
05690 opacity_int = opacity*255.;
05691 top_opc = opac_correct[opacity_int];
05692 } else {
05693 top_opc = (float)0.;
05694 };
05695
05696
05697 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
05698 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
05699
05700
05701
05702 top_clr =
05703 shade_table[shade_index + 1*0 + 0] *
05704 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05705
05706 top_sclr =
05707 shadow_table[shade_index + 1*0 + 0] *
05708 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05709 for (m = 1; m < num_materials; m++) {
05710
05711
05712 top_clr +=
05713 shade_table[shade_index + 1*m + 0] *
05714 weight_table[weight_index + m];
05715
05716 top_sclr +=
05717 shadow_table[shade_index + 1*m + 0] *
05718 weight_table[weight_index + m];
05719 };
05720 shade_factor = top_opc * slice_depth_cueing;
05721
05722 top_clr *= shade_factor;
05723
05724 top_sclr *= shade_factor;
05725
05726
05727 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
05728 opacity = param0_table[opac_param];
05729 if (param1_size != 0) {
05730 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
05731 opacity *= param1_table[opac_param];
05732 if (param2_size != 0) {
05733 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
05734 opacity *= param2_table[opac_param];
05735 }
05736 }
05737 if (opacity > min_opacity) {
05738 opacity_int = opacity*255.;
05739 bot_opc = opac_correct[opacity_int];
05740 } else {
05741 bot_opc = (float)0.;
05742 };
05743
05744
05745 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
05746 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
05747
05748
05749
05750 bot_clr =
05751 shade_table[shade_index + 1*0 + 0] *
05752 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05753
05754 bot_sclr =
05755 shadow_table[shade_index + 1*0 + 0] *
05756 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05757 for (m = 1; m < num_materials; m++) {
05758
05759
05760 bot_clr +=
05761 shade_table[shade_index + 1*m + 0] *
05762 weight_table[weight_index + m];
05763
05764 bot_sclr +=
05765 shadow_table[shade_index + 1*m + 0] *
05766 weight_table[weight_index + m];
05767 };
05768 shade_factor = bot_opc * slice_depth_cueing;
05769
05770 bot_clr *= shade_factor;
05771
05772 bot_sclr *= shade_factor;
05773 }
05774
05775 #ifdef DEBUG
05776 if (ipixel == trace_pixel_ptr) {
05777 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
05778 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
05779 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
05780 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
05781 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
05782 }
05783 #endif
05784 ;
05785
05786 acc_opc = top_opc * wgtTL;
05787 acc_clr = (top_clr + top_sclr *
05788 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
05789
05790 #ifdef DEBUG
05791 if (ipixel == trace_pixel_ptr) {
05792 trace_opcTL = top_opc;
05793 trace_rclrTL = top_clr;
05794 trace_rsclrTL = top_sclr;
05795 }
05796 #endif
05797 ;
05798
05799 acc_opc += bot_opc * wgtBL;
05800 acc_clr += (bot_clr + bot_sclr *
05801 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
05802
05803 #ifdef DEBUG
05804 if (ipixel == trace_pixel_ptr) {
05805 trace_opcBL = bot_opc;
05806 trace_rclrBL = bot_clr;
05807 trace_rsclrBL = bot_sclr;
05808 }
05809 #endif
05810 ;
05811
05812
05813 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
05814 opacity = param0_table[opac_param];
05815 if (param1_size != 0) {
05816 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
05817 opacity *= param1_table[opac_param];
05818 if (param2_size != 0) {
05819 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
05820 opacity *= param2_table[opac_param];
05821 }
05822 }
05823 if (opacity > min_opacity) {
05824 opacity_int = opacity*255.;
05825 top_opc = opac_correct[opacity_int];
05826 } else {
05827 top_opc = (float)0.;
05828 };
05829
05830
05831 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
05832 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
05833
05834
05835
05836 top_clr =
05837 shade_table[shade_index + 1*0 + 0] *
05838 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05839
05840 top_sclr =
05841 shadow_table[shade_index + 1*0 + 0] *
05842 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05843 for (m = 1; m < num_materials; m++) {
05844
05845
05846 top_clr +=
05847 shade_table[shade_index + 1*m + 0] *
05848 weight_table[weight_index + m];
05849
05850 top_sclr +=
05851 shadow_table[shade_index + 1*m + 0] *
05852 weight_table[weight_index + m];
05853 };
05854 shade_factor = top_opc * slice_depth_cueing;
05855
05856 top_clr *= shade_factor;
05857
05858 top_sclr *= shade_factor;
05859
05860
05861 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
05862 opacity = param0_table[opac_param];
05863 if (param1_size != 0) {
05864 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
05865 opacity *= param1_table[opac_param];
05866 if (param2_size != 0) {
05867 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
05868 opacity *= param2_table[opac_param];
05869 }
05870 }
05871 if (opacity > min_opacity) {
05872 opacity_int = opacity*255.;
05873 bot_opc = opac_correct[opacity_int];
05874 } else {
05875 bot_opc = (float)0.;
05876 };
05877
05878
05879 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
05880 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
05881
05882
05883
05884 bot_clr =
05885 shade_table[shade_index + 1*0 + 0] *
05886 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05887
05888 bot_sclr =
05889 shadow_table[shade_index + 1*0 + 0] *
05890 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
05891 for (m = 1; m < num_materials; m++) {
05892
05893
05894 bot_clr +=
05895 shade_table[shade_index + 1*m + 0] *
05896 weight_table[weight_index + m];
05897
05898 bot_sclr +=
05899 shadow_table[shade_index + 1*m + 0] *
05900 weight_table[weight_index + m];
05901 };
05902 shade_factor = bot_opc * slice_depth_cueing;
05903
05904 bot_clr *= shade_factor;
05905
05906 bot_sclr *= shade_factor;
05907
05908 acc_opc += top_opc * wgtTR;
05909 acc_clr += (top_clr + top_sclr *
05910 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
05911
05912 #ifdef DEBUG
05913 if (ipixel == trace_pixel_ptr) {
05914 trace_opcTR = top_opc;
05915 trace_rclrTR = top_clr;
05916 trace_rsclrTR = top_sclr;
05917 }
05918 #endif
05919 ;
05920
05921 acc_opc += bot_opc * wgtBR;
05922 acc_clr += (bot_clr + bot_sclr *
05923 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
05924
05925 #ifdef DEBUG
05926 if (ipixel == trace_pixel_ptr) {
05927 trace_opcBR = bot_opc;
05928 trace_rclrBR = bot_clr;
05929 trace_rsclrBR = bot_sclr;
05930 }
05931 #endif
05932 ;
05933
05934 COUNT_RESAMPLE;
05935 if (acc_opc > min_opacity) {
05936 COUNT_COMPOSITE;
05937 iopc = ipixel->opcflt;
05938 # ifndef SKIP_ERT
05939 ASSERT(iopc < max_opacity);
05940 # endif
05941 iopc_inv = (float)1. - iopc;
05942 ipixel->clrflt += acc_clr * iopc_inv;
05943 iopc += acc_opc * iopc_inv;
05944 ipixel->opcflt = iopc;
05945
05946 #ifdef DEBUG
05947 if (ipixel == trace_pixel_ptr) {
05948 #ifdef COMPUTE_SHADOW_BUFFER
05949 printf("{%3d} %3d %3d", k, icount-i-count, j);
05950 #else
05951 printf("[%3d] %3d %3d", k, icount-i-count, j);
05952 #endif
05953 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
05954 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
05955 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
05956 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
05957 printf(" %3.0f %3.0f\n", iopc*255.,
05958 ipixel->clrflt);
05959
05960 printf(" ");
05961 printf(" %3.0f ",trace_rsclrTL);
05962 printf(" %3.0f ",trace_rsclrBL);
05963 printf(" %3.0f ",trace_rsclrTR);
05964 printf(" %3.0f ",trace_rsclrBR);
05965 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
05966
05967 }
05968 #endif
05969 ;
05970 # ifndef SKIP_ERT
05971 if (iopc >= max_opacity) {
05972 ASSERT(ipixel->lnk == 0);
05973 ipixel->lnk = 1;
05974 }
05975 # endif
05976 };
05977 ipixel += 1; shadow_pixel += 1;
05978 topRLEdata += 1 * voxel_istride;
05979 botRLEdata += 1 * voxel_istride;
05980 count--;
05981 SET_VOXELS_LOADED;
05982 }
05983 break;
05984 default:
05985 VPBug("illegal value for run states in compositing loop");
05986 }
05987 #else
05988
05989 while (count > 0) {
05990 if (last_run_state == ALL_ZERO && run_state == ALL_ZERO) {
05991 ipixel += count; shadow_pixel += count;
05992 if (i != -1) {
05993 topRLEdata += count * voxel_istride;
05994 botRLEdata += count * voxel_istride;
05995 }
05996 count = 0;
05997 break;
05998 }
05999 if (ipixel->lnk != 0)
06000 break;
06001
06002 #ifdef DEBUG
06003 if (ipixel == trace_pixel_ptr) {
06004 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
06005 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
06006 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
06007 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
06008 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
06009 }
06010 #endif
06011 ;
06012
06013 acc_opc = 0;
06014 acc_clr = 0;
06015 if (last_run_state & TOP_NONZERO) {
06016 if (!voxels_loaded) {
06017
06018
06019 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
06020 opacity = param0_table[opac_param];
06021 if (param1_size != 0) {
06022 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
06023 opacity *= param1_table[opac_param];
06024 if (param2_size != 0) {
06025 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
06026 opacity *= param2_table[opac_param];
06027 }
06028 }
06029 if (opacity > min_opacity) {
06030 opacity_int = opacity*255.;
06031 top_opc = opac_correct[opacity_int];
06032 } else {
06033 top_opc = (float)0.;
06034 };
06035
06036
06037 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
06038 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
06039
06040
06041
06042 top_clr =
06043 shade_table[shade_index + 1*0 + 0] *
06044 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06045
06046 top_sclr =
06047 shadow_table[shade_index + 1*0 + 0] *
06048 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06049 for (m = 1; m < num_materials; m++) {
06050
06051
06052 top_clr +=
06053 shade_table[shade_index + 1*m + 0] *
06054 weight_table[weight_index + m];
06055
06056 top_sclr +=
06057 shadow_table[shade_index + 1*m + 0] *
06058 weight_table[weight_index + m];
06059 };
06060 shade_factor = top_opc * slice_depth_cueing;
06061
06062 top_clr *= shade_factor;
06063
06064 top_sclr *= shade_factor;
06065 }
06066
06067 acc_opc += top_opc * wgtTL;
06068 acc_clr += (top_clr + top_sclr *
06069 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
06070
06071 #ifdef DEBUG
06072 if (ipixel == trace_pixel_ptr) {
06073 trace_opcTL = top_opc;
06074 trace_rclrTL = top_clr;
06075 trace_rsclrTL = top_sclr;
06076 }
06077 #endif
06078 ;
06079 }
06080 if (last_run_state & BOT_NONZERO) {
06081 if (!voxels_loaded) {
06082
06083
06084 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
06085 opacity = param0_table[opac_param];
06086 if (param1_size != 0) {
06087 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
06088 opacity *= param1_table[opac_param];
06089 if (param2_size != 0) {
06090 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
06091 opacity *= param2_table[opac_param];
06092 }
06093 }
06094 if (opacity > min_opacity) {
06095 opacity_int = opacity*255.;
06096 bot_opc = opac_correct[opacity_int];
06097 } else {
06098 bot_opc = (float)0.;
06099 };
06100
06101
06102 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
06103 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
06104
06105
06106
06107 bot_clr =
06108 shade_table[shade_index + 1*0 + 0] *
06109 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06110
06111 bot_sclr =
06112 shadow_table[shade_index + 1*0 + 0] *
06113 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06114 for (m = 1; m < num_materials; m++) {
06115
06116
06117 bot_clr +=
06118 shade_table[shade_index + 1*m + 0] *
06119 weight_table[weight_index + m];
06120
06121 bot_sclr +=
06122 shadow_table[shade_index + 1*m + 0] *
06123 weight_table[weight_index + m];
06124 };
06125 shade_factor = bot_opc * slice_depth_cueing;
06126
06127 bot_clr *= shade_factor;
06128
06129 bot_sclr *= shade_factor;
06130 }
06131
06132 acc_opc += bot_opc * wgtBL;
06133 acc_clr += (bot_clr + bot_sclr *
06134 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
06135
06136 #ifdef DEBUG
06137 if (ipixel == trace_pixel_ptr) {
06138 trace_opcBL = bot_opc;
06139 trace_rclrBL = bot_clr;
06140 trace_rsclrBL = bot_sclr;
06141 }
06142 #endif
06143 ;
06144 }
06145 if (run_state & TOP_NONZERO) {
06146
06147
06148 opac_param = VoxelField(topRLEdata, param0_offset, param0_size);
06149 opacity = param0_table[opac_param];
06150 if (param1_size != 0) {
06151 opac_param = VoxelField(topRLEdata, param1_offset, param1_size);
06152 opacity *= param1_table[opac_param];
06153 if (param2_size != 0) {
06154 opac_param = VoxelField(topRLEdata, param2_offset, param2_size);
06155 opacity *= param2_table[opac_param];
06156 }
06157 }
06158 if (opacity > min_opacity) {
06159 opacity_int = opacity*255.;
06160 top_opc = opac_correct[opacity_int];
06161 } else {
06162 top_opc = (float)0.;
06163 };
06164
06165
06166 shade_index=num_materials*1*ShortField(topRLEdata,norm_offset);
06167 weight_index = num_materials * ByteField(topRLEdata, wgt_offset);
06168
06169
06170
06171 top_clr =
06172 shade_table[shade_index + 1*0 + 0] *
06173 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06174
06175 top_sclr =
06176 shadow_table[shade_index + 1*0 + 0] *
06177 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06178 for (m = 1; m < num_materials; m++) {
06179
06180
06181 top_clr +=
06182 shade_table[shade_index + 1*m + 0] *
06183 weight_table[weight_index + m];
06184
06185 top_sclr +=
06186 shadow_table[shade_index + 1*m + 0] *
06187 weight_table[weight_index + m];
06188 };
06189 shade_factor = top_opc * slice_depth_cueing;
06190
06191 top_clr *= shade_factor;
06192
06193 top_sclr *= shade_factor;
06194
06195 acc_opc += top_opc * wgtTR;
06196 acc_clr += (top_clr + top_sclr *
06197 ((float)1.0 - shadow_pixel->opcflt)) * wgtTR;
06198
06199 #ifdef DEBUG
06200 if (ipixel == trace_pixel_ptr) {
06201 trace_opcTR = top_opc;
06202 trace_rclrTR = top_clr;
06203 trace_rsclrTR = top_sclr;
06204 }
06205 #endif
06206 ;
06207 topRLEdata += 1 * voxel_istride;
06208 } else {
06209 if (i != -1) {
06210 topRLEdata += 1 * voxel_istride;
06211 }
06212 }
06213 if (run_state & BOT_NONZERO) {
06214
06215
06216 opac_param = VoxelField(botRLEdata, param0_offset, param0_size);
06217 opacity = param0_table[opac_param];
06218 if (param1_size != 0) {
06219 opac_param = VoxelField(botRLEdata, param1_offset, param1_size);
06220 opacity *= param1_table[opac_param];
06221 if (param2_size != 0) {
06222 opac_param = VoxelField(botRLEdata, param2_offset, param2_size);
06223 opacity *= param2_table[opac_param];
06224 }
06225 }
06226 if (opacity > min_opacity) {
06227 opacity_int = opacity*255.;
06228 bot_opc = opac_correct[opacity_int];
06229 } else {
06230 bot_opc = (float)0.;
06231 };
06232
06233
06234 shade_index=num_materials*1*ShortField(botRLEdata,norm_offset);
06235 weight_index = num_materials * ByteField(botRLEdata, wgt_offset);
06236
06237
06238
06239 bot_clr =
06240 shade_table[shade_index + 1*0 + 0] *
06241 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06242
06243 bot_sclr =
06244 shadow_table[shade_index + 1*0 + 0] *
06245 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06246 for (m = 1; m < num_materials; m++) {
06247
06248
06249 bot_clr +=
06250 shade_table[shade_index + 1*m + 0] *
06251 weight_table[weight_index + m];
06252
06253 bot_sclr +=
06254 shadow_table[shade_index + 1*m + 0] *
06255 weight_table[weight_index + m];
06256 };
06257 shade_factor = bot_opc * slice_depth_cueing;
06258
06259 bot_clr *= shade_factor;
06260
06261 bot_sclr *= shade_factor;
06262
06263 acc_opc += bot_opc * wgtBR;
06264 acc_clr += (bot_clr + bot_sclr *
06265 ((float)1.0 - shadow_pixel->opcflt)) * wgtBR;
06266
06267 #ifdef DEBUG
06268 if (ipixel == trace_pixel_ptr) {
06269 trace_opcBR = bot_opc;
06270 trace_rclrBR = bot_clr;
06271 trace_rsclrBR = bot_sclr;
06272 }
06273 #endif
06274 ;
06275 botRLEdata += 1 * voxel_istride;
06276 } else {
06277 if (i != -1) {
06278 botRLEdata += 1 * voxel_istride;
06279 }
06280 }
06281
06282 COUNT_RESAMPLE;
06283 if (acc_opc > min_opacity) {
06284 COUNT_COMPOSITE;
06285 iopc = ipixel->opcflt;
06286 # ifndef SKIP_ERT
06287 ASSERT(iopc < max_opacity);
06288 # endif
06289 iopc_inv = (float)1. - iopc;
06290 ipixel->clrflt += acc_clr * iopc_inv;
06291 iopc += acc_opc * iopc_inv;
06292 ipixel->opcflt = iopc;
06293
06294 #ifdef DEBUG
06295 if (ipixel == trace_pixel_ptr) {
06296 #ifdef COMPUTE_SHADOW_BUFFER
06297 printf("{%3d} %3d %3d", k, icount-i-count, j);
06298 #else
06299 printf("[%3d] %3d %3d", k, icount-i-count, j);
06300 #endif
06301 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
06302 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
06303 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
06304 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
06305 printf(" %3.0f %3.0f\n", iopc*255.,
06306 ipixel->clrflt);
06307
06308 printf(" ");
06309 printf(" %3.0f ",trace_rsclrTL);
06310 printf(" %3.0f ",trace_rsclrBL);
06311 printf(" %3.0f ",trace_rsclrTR);
06312 printf(" %3.0f ",trace_rsclrBR);
06313 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
06314
06315 }
06316 #endif
06317 ;
06318 # ifndef SKIP_ERT
06319 if (iopc >= max_opacity) {
06320 ASSERT(ipixel->lnk == 0);
06321 ipixel->lnk = 1;
06322 }
06323 # endif
06324 };
06325 ipixel += 1; shadow_pixel += 1;
06326 count--;
06327 SET_VOXELS_LOADED;
06328 last_run_state = run_state;
06329 }
06330 #endif
06331
06332 GET_HIRES_TIME(vpc, t1);
06333 STORE_HIRES_TIME(vpc, VPTIMER_PROCESS_VOXELS, t0, t1);
06334 COPY_HIRES_TIME(t0, t1);
06335
06336 if (count > 0) {
06337 Debug((vpc, VPDEBUG_COMPOSITE, "Backup(%d)\n", count));
06338 toprun_count += count;
06339 botrun_count += count;
06340 i += count;
06341 }
06342 #endif
06343
06344
06345
06346
06347
06348 last_run_state = run_state;
06349 }
06350
06351
06352
06353
06354
06355 #ifdef UNROLL_RUN_LOOP
06356 ASSERT(i == 0);
06357 #else
06358 ASSERT(i == -1);
06359 #endif
06360
06361 #ifndef SKIP_COMPOSITE
06362 #ifdef UNROLL_RUN_LOOP
06363
06364 if (last_run_state != ALL_ZERO && !PIXEL_IS_OPAQUE(ipixel)) {
06365
06366
06367 Debug((vpc, VPDEBUG_COMPOSITE, "Run(1)End\n"));
06368 switch (last_run_state) {
06369 case TOP_NONZERO:
06370
06371 if (!voxels_loaded) {
06372
06373
06374 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
06375 opacity = param0_table[opac_param];
06376 if (param1_size != 0) {
06377 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
06378 opacity *= param1_table[opac_param];
06379 if (param2_size != 0) {
06380 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
06381 opacity *= param2_table[opac_param];
06382 }
06383 }
06384 if (opacity > min_opacity) {
06385 opacity_int = opacity*255.;
06386 top_opc = opac_correct[opacity_int];
06387 } else {
06388 top_opc = (float)0.;
06389 };
06390
06391
06392 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
06393 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
06394
06395
06396
06397 top_clr =
06398 shade_table[shade_index + 1*0 + 0] *
06399 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06400
06401 top_sclr =
06402 shadow_table[shade_index + 1*0 + 0] *
06403 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06404 for (m = 1; m < num_materials; m++) {
06405
06406
06407 top_clr +=
06408 shade_table[shade_index + 1*m + 0] *
06409 weight_table[weight_index + m];
06410
06411 top_sclr +=
06412 shadow_table[shade_index + 1*m + 0] *
06413 weight_table[weight_index + m];
06414 };
06415 shade_factor = top_opc * slice_depth_cueing;
06416
06417 top_clr *= shade_factor;
06418
06419 top_sclr *= shade_factor;
06420 }
06421
06422 #ifdef DEBUG
06423 if (ipixel == trace_pixel_ptr) {
06424 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
06425 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
06426 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
06427 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
06428 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
06429 }
06430 #endif
06431 ;
06432
06433 acc_opc = top_opc * wgtTL;
06434 acc_clr = (top_clr + top_sclr *
06435 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
06436
06437 #ifdef DEBUG
06438 if (ipixel == trace_pixel_ptr) {
06439 trace_opcTL = top_opc;
06440 trace_rclrTL = top_clr;
06441 trace_rsclrTL = top_sclr;
06442 }
06443 #endif
06444 ;
06445
06446 COUNT_RESAMPLE;
06447 if (acc_opc > min_opacity) {
06448 COUNT_COMPOSITE;
06449 iopc = ipixel->opcflt;
06450 # ifndef SKIP_ERT
06451 ASSERT(iopc < max_opacity);
06452 # endif
06453 iopc_inv = (float)1. - iopc;
06454 ipixel->clrflt += acc_clr * iopc_inv;
06455 iopc += acc_opc * iopc_inv;
06456 ipixel->opcflt = iopc;
06457
06458 #ifdef DEBUG
06459 if (ipixel == trace_pixel_ptr) {
06460 #ifdef COMPUTE_SHADOW_BUFFER
06461 printf("{%3d} %3d %3d", k, icount-i-count, j);
06462 #else
06463 printf("[%3d] %3d %3d", k, icount-i-count, j);
06464 #endif
06465 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
06466 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
06467 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
06468 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
06469 printf(" %3.0f %3.0f\n", iopc*255.,
06470 ipixel->clrflt);
06471
06472 printf(" ");
06473 printf(" %3.0f ",trace_rsclrTL);
06474 printf(" %3.0f ",trace_rsclrBL);
06475 printf(" %3.0f ",trace_rsclrTR);
06476 printf(" %3.0f ",trace_rsclrBR);
06477 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
06478
06479 }
06480 #endif
06481 ;
06482 # ifndef SKIP_ERT
06483 if (iopc >= max_opacity) {
06484 ASSERT(ipixel->lnk == 0);
06485 ipixel->lnk = 1;
06486 }
06487 # endif
06488 };
06489 break;
06490 case BOT_NONZERO:
06491
06492 if (!voxels_loaded) {
06493
06494
06495 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
06496 opacity = param0_table[opac_param];
06497 if (param1_size != 0) {
06498 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
06499 opacity *= param1_table[opac_param];
06500 if (param2_size != 0) {
06501 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
06502 opacity *= param2_table[opac_param];
06503 }
06504 }
06505 if (opacity > min_opacity) {
06506 opacity_int = opacity*255.;
06507 bot_opc = opac_correct[opacity_int];
06508 } else {
06509 bot_opc = (float)0.;
06510 };
06511
06512
06513 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
06514 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
06515
06516
06517
06518 bot_clr =
06519 shade_table[shade_index + 1*0 + 0] *
06520 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06521
06522 bot_sclr =
06523 shadow_table[shade_index + 1*0 + 0] *
06524 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06525 for (m = 1; m < num_materials; m++) {
06526
06527
06528 bot_clr +=
06529 shade_table[shade_index + 1*m + 0] *
06530 weight_table[weight_index + m];
06531
06532 bot_sclr +=
06533 shadow_table[shade_index + 1*m + 0] *
06534 weight_table[weight_index + m];
06535 };
06536 shade_factor = bot_opc * slice_depth_cueing;
06537
06538 bot_clr *= shade_factor;
06539
06540 bot_sclr *= shade_factor;
06541 }
06542
06543 #ifdef DEBUG
06544 if (ipixel == trace_pixel_ptr) {
06545 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
06546 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
06547 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
06548 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
06549 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
06550 }
06551 #endif
06552 ;
06553
06554 acc_opc = bot_opc * wgtBL;
06555 acc_clr = (bot_clr + bot_sclr *
06556 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
06557
06558 #ifdef DEBUG
06559 if (ipixel == trace_pixel_ptr) {
06560 trace_opcBL = bot_opc;
06561 trace_rclrBL = bot_clr;
06562 trace_rsclrBL = bot_sclr;
06563 }
06564 #endif
06565 ;
06566
06567 COUNT_RESAMPLE;
06568 if (acc_opc > min_opacity) {
06569 COUNT_COMPOSITE;
06570 iopc = ipixel->opcflt;
06571 # ifndef SKIP_ERT
06572 ASSERT(iopc < max_opacity);
06573 # endif
06574 iopc_inv = (float)1. - iopc;
06575 ipixel->clrflt += acc_clr * iopc_inv;
06576 iopc += acc_opc * iopc_inv;
06577 ipixel->opcflt = iopc;
06578
06579 #ifdef DEBUG
06580 if (ipixel == trace_pixel_ptr) {
06581 #ifdef COMPUTE_SHADOW_BUFFER
06582 printf("{%3d} %3d %3d", k, icount-i-count, j);
06583 #else
06584 printf("[%3d] %3d %3d", k, icount-i-count, j);
06585 #endif
06586 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
06587 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
06588 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
06589 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
06590 printf(" %3.0f %3.0f\n", iopc*255.,
06591 ipixel->clrflt);
06592
06593 printf(" ");
06594 printf(" %3.0f ",trace_rsclrTL);
06595 printf(" %3.0f ",trace_rsclrBL);
06596 printf(" %3.0f ",trace_rsclrTR);
06597 printf(" %3.0f ",trace_rsclrBR);
06598 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
06599
06600 }
06601 #endif
06602 ;
06603 # ifndef SKIP_ERT
06604 if (iopc >= max_opacity) {
06605 ASSERT(ipixel->lnk == 0);
06606 ipixel->lnk = 1;
06607 }
06608 # endif
06609 };
06610 break;
06611 case ALL_NONZERO:
06612
06613 if (!voxels_loaded) {
06614
06615
06616 opac_param = VoxelField(topRLEdata - voxel_istride, param0_offset, param0_size);
06617 opacity = param0_table[opac_param];
06618 if (param1_size != 0) {
06619 opac_param = VoxelField(topRLEdata - voxel_istride, param1_offset, param1_size);
06620 opacity *= param1_table[opac_param];
06621 if (param2_size != 0) {
06622 opac_param = VoxelField(topRLEdata - voxel_istride, param2_offset, param2_size);
06623 opacity *= param2_table[opac_param];
06624 }
06625 }
06626 if (opacity > min_opacity) {
06627 opacity_int = opacity*255.;
06628 top_opc = opac_correct[opacity_int];
06629 } else {
06630 top_opc = (float)0.;
06631 };
06632
06633
06634 shade_index=num_materials*1*ShortField(topRLEdata - voxel_istride,norm_offset);
06635 weight_index = num_materials * ByteField(topRLEdata - voxel_istride, wgt_offset);
06636
06637
06638
06639 top_clr =
06640 shade_table[shade_index + 1*0 + 0] *
06641 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06642
06643 top_sclr =
06644 shadow_table[shade_index + 1*0 + 0] *
06645 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06646 for (m = 1; m < num_materials; m++) {
06647
06648
06649 top_clr +=
06650 shade_table[shade_index + 1*m + 0] *
06651 weight_table[weight_index + m];
06652
06653 top_sclr +=
06654 shadow_table[shade_index + 1*m + 0] *
06655 weight_table[weight_index + m];
06656 };
06657 shade_factor = top_opc * slice_depth_cueing;
06658
06659 top_clr *= shade_factor;
06660
06661 top_sclr *= shade_factor;
06662
06663
06664 opac_param = VoxelField(botRLEdata - voxel_istride, param0_offset, param0_size);
06665 opacity = param0_table[opac_param];
06666 if (param1_size != 0) {
06667 opac_param = VoxelField(botRLEdata - voxel_istride, param1_offset, param1_size);
06668 opacity *= param1_table[opac_param];
06669 if (param2_size != 0) {
06670 opac_param = VoxelField(botRLEdata - voxel_istride, param2_offset, param2_size);
06671 opacity *= param2_table[opac_param];
06672 }
06673 }
06674 if (opacity > min_opacity) {
06675 opacity_int = opacity*255.;
06676 bot_opc = opac_correct[opacity_int];
06677 } else {
06678 bot_opc = (float)0.;
06679 };
06680
06681
06682 shade_index=num_materials*1*ShortField(botRLEdata - voxel_istride,norm_offset);
06683 weight_index = num_materials * ByteField(botRLEdata - voxel_istride, wgt_offset);
06684
06685
06686
06687 bot_clr =
06688 shade_table[shade_index + 1*0 + 0] *
06689 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06690
06691 bot_sclr =
06692 shadow_table[shade_index + 1*0 + 0] *
06693 ((num_materials > 1) ? weight_table[weight_index] : (float)1.0);
06694 for (m = 1; m < num_materials; m++) {
06695
06696
06697 bot_clr +=
06698 shade_table[shade_index + 1*m + 0] *
06699 weight_table[weight_index + m];
06700
06701 bot_sclr +=
06702 shadow_table[shade_index + 1*m + 0] *
06703 weight_table[weight_index + m];
06704 };
06705 shade_factor = bot_opc * slice_depth_cueing;
06706
06707 bot_clr *= shade_factor;
06708
06709 bot_sclr *= shade_factor;
06710 }
06711
06712 #ifdef DEBUG
06713 if (ipixel == trace_pixel_ptr) {
06714 trace_opcTL = 0.; trace_opcBL = 0.; trace_opcTR = 0.; trace_opcBR = 0.;
06715 trace_rsclrTL=0.; trace_rsclrBL=0.; trace_rsclrTR=0.; trace_rsclrBR=0.;
06716 trace_rclrTL= 0.; trace_rclrBL= 0.; trace_rclrTR= 0.; trace_rclrBR= 0.;
06717 trace_gclrTL= 0.; trace_gclrBL= 0.; trace_gclrTR= 0.; trace_gclrBR= 0.;
06718 trace_bclrTL= 0.; trace_bclrBL= 0.; trace_bclrTR= 0.; trace_bclrBR= 0.;
06719 }
06720 #endif
06721 ;
06722
06723 acc_opc = top_opc * wgtTL;
06724 acc_clr = (top_clr + top_sclr *
06725 ((float)1.0 - shadow_pixel->opcflt)) * wgtTL;
06726
06727 #ifdef DEBUG
06728 if (ipixel == trace_pixel_ptr) {
06729 trace_opcTL = top_opc;
06730 trace_rclrTL = top_clr;
06731 trace_rsclrTL = top_sclr;
06732 }
06733 #endif
06734 ;
06735
06736 acc_opc += bot_opc * wgtBL;
06737 acc_clr += (bot_clr + bot_sclr *
06738 ((float)1.0 - shadow_pixel->opcflt)) * wgtBL;
06739
06740 #ifdef DEBUG
06741 if (ipixel == trace_pixel_ptr) {
06742 trace_opcBL = bot_opc;
06743 trace_rclrBL = bot_clr;
06744 trace_rsclrBL = bot_sclr;
06745 }
06746 #endif
06747 ;
06748
06749 COUNT_RESAMPLE;
06750 if (acc_opc > min_opacity) {
06751 COUNT_COMPOSITE;
06752 iopc = ipixel->opcflt;
06753 # ifndef SKIP_ERT
06754 ASSERT(iopc < max_opacity);
06755 # endif
06756 iopc_inv = (float)1. - iopc;
06757 ipixel->clrflt += acc_clr * iopc_inv;
06758 iopc += acc_opc * iopc_inv;
06759 ipixel->opcflt = iopc;
06760
06761 #ifdef DEBUG
06762 if (ipixel == trace_pixel_ptr) {
06763 #ifdef COMPUTE_SHADOW_BUFFER
06764 printf("{%3d} %3d %3d", k, icount-i-count, j);
06765 #else
06766 printf("[%3d] %3d %3d", k, icount-i-count, j);
06767 #endif
06768 printf(" %3.0f %3.0f %3.0f",trace_opcTL*255.,trace_rclrTL,wgtTL*100.);
06769 printf(" %3.0f %3.0f %3.0f",trace_opcBL*255.,trace_rclrBL,wgtBL*100.);
06770 printf(" %3.0f %3.0f %3.0f",trace_opcTR*255.,trace_rclrTR,wgtTR*100.);
06771 printf(" %3.0f %3.0f %3.0f",trace_opcBR*255.,trace_rclrBR,wgtBR*100.);
06772 printf(" %3.0f %3.0f\n", iopc*255.,
06773 ipixel->clrflt);
06774
06775 printf(" ");
06776 printf(" %3.0f ",trace_rsclrTL);
06777 printf(" %3.0f ",trace_rsclrBL);
06778 printf(" %3.0f ",trace_rsclrTR);
06779 printf(" %3.0f ",trace_rsclrBR);
06780 printf(" %3.0f\n", shadow_pixel->opcflt * 255.);
06781
06782 }
06783 #endif
06784 ;
06785 # ifndef SKIP_ERT
06786 if (iopc >= max_opacity) {
06787 ASSERT(ipixel->lnk == 0);
06788 ipixel->lnk = 1;
06789 }
06790 # endif
06791 };
06792 break;
06793 default:
06794 VPBug("illegal value for run state at end of scanline");
06795 }
06796 } else if (last_run_state == ALL_ZERO) {
06797 Debug((vpc, VPDEBUG_COMPOSITE, "ZeroSkip(1)End\n"));
06798 } else {
06799 Debug((vpc, VPDEBUG_COMPOSITE, "ERTSkip(1)End\n"));
06800 }
06801 #endif
06802 #endif
06803
06804 #ifndef UNROLL_RUN_LOOP
06805 run_state = final_run_state;
06806 #endif
06807
06808 if (j != 0 && ((run_state & 1) == 0)) {
06809 toprun_count = *topRLElen++;
06810 ASSERT(toprun_count == 0);
06811 }
06812 if (j != jcount && ((run_state & 2) == 0)) {
06813 botrun_count = *botRLElen++;
06814 ASSERT(botrun_count == 0);
06815 }
06816
06817
06818 #ifdef UNROLL_RUN_LOOP
06819 ipixel += intermediate_width - icount;
06820 #ifdef USE_SHADOW_BUFFER
06821 shadow_pixel += shadow_width - icount;
06822 #endif
06823 #else
06824 ipixel += intermediate_width - (icount+1);
06825 #ifdef USE_SHADOW_BUFFER
06826 shadow_pixel += shadow_width - (icount+1);
06827 #endif
06828 #endif
06829
06830 Debug((vpc, VPDEBUG_COMPOSITE, "ScanDone\n"));
06831 }
06832
06833
06834
06835
06836
06837 GET_HIRES_TIME(vpc, t1);
06838 STORE_HIRES_TIME(vpc, VPTIMER_TRAVERSE_RUNS, t0, t1);
06839
06840 Debug((vpc, VPDEBUG_COMPOSITE, "SliceDone\n"));
06841 }