1
2#ifdef SEGLEN
3//Update step cell functor::seg_len
4void step_cell_seglen(AuxArgs aux_args, int data_ptr, uchar llid, float d)
5{
6    int seg_int = convert_int_rte(d * SEGLEN_FACTOR);
7    atom_add(&aux_args.seg_len[data_ptr], seg_int);
8
9    //increment mean observation
10    int cum_obsR = convert_int_rte(d * aux_args.obs.x * SEGLEN_FACTOR);
11    int cum_obsG = convert_int_rte(d * aux_args.obs.y * SEGLEN_FACTOR);
12    int cum_obsB = convert_int_rte(d * aux_args.obs.z * SEGLEN_FACTOR);
13    atom_add(&aux_args.mean_obsR[data_ptr], cum_obsR);
14    atom_add(&aux_args.mean_obsG[data_ptr], cum_obsG);
15    atom_add(&aux_args.mean_obsB[data_ptr], cum_obsB);
16
17
18    //reset cell_ptrs to negative one every time (prevents invisible layer bug)
19    aux_args.cell_ptrs[llid] = -1;
20}
21#endif // SEGLEN
22
23#ifdef PREINF
24
25void pre_infinity_opt_view_based(  float    seg_len,
26                                    float    cum_len,
27                                    float4    mean_obs,
28                                    float  * vis_inf,
29                                    float  * pre_inf,
30                                    float    alpha,
31                                    MOG_TYPE   mixture,
32                                    float8 nobs,
33                                    float* app_model_weights)
34{
35    /* if total length of rays is too small, do nothing */
36    float PI = 0.0f;
37    if (cum_len>1.0e-10f)
38    {
39        PI = view_dep_mixture_model(mean_obs, mixture, app_model_weights);
40
41        /* Calculate pre and vis infinity */
42        float diff_omega = exp(-alpha * seg_len);
43        float vis_prob_end = (*vis_inf) * diff_omega;
44
45        /* updated pre                      Omega         *   PI  */
46        (*pre_inf) += ((*vis_inf) - vis_prob_end) *  PI;
47
48        /* updated visibility probability */
49        (*vis_inf) = vis_prob_end;
50  }
51}
52
53//preinf step cell functor
54void step_cell_preinf(AuxArgs aux_args, int data_ptr, uchar llid, float d)
55{
56    //keep track of cells being hit
57    ////cell data, i.e., alpha and app model is needed for some passes
58    float  alpha    = aux_args.alpha[data_ptr];
59    MOG_TYPE mixture = aux_args.mog[data_ptr];
60    float8 num_obs = aux_args.num_obs[data_ptr];
61
62#ifdef YUV
63    float4 mean_obs = unpack_yuv(aux_args.mean_obs[data_ptr]);
64#else
65    float4 mean_obs = convert_float4(unpack_uchar4(aux_args.mean_obs[data_ptr])) * 255.0f;
66#endif
67
68    float cum_len = convert_float( aux_args.seg_len[data_ptr]) / SEGLEN_FACTOR;
69
70    //calculate pre_infinity denomanator (shape of image)
71    pre_infinity_opt_view_based( d*aux_args.linfo->block_len,
72                                  cum_len*aux_args.linfo->block_len,
73                                  mean_obs,
74                                  aux_args.vis_inf,
75                                  aux_args.pre_inf,
76                                  alpha,
77                                  mixture,
78                                  num_obs,
79                                  aux_args.app_model_weights);
80
81    aux_args.ray_dir[data_ptr] = aux_args.viewdir;
82}
83#endif // PREINF
84
85#ifdef BAYES
86
87
88/* bayes ratio independent functor (for independent rays) */
89void bayes_ratio_ind_view_based( float  seg_len,
90                                  float  alpha,
91                                  MOG_TYPE mixture,
92                                  float8 nobs,
93                                  float* app_model_weights,
94                                  float  cum_len,
95                                  float4  mean_obs,
96                                  float  norm,
97                                  float* ray_pre,
98                                  float* ray_vis,
99                                  float* ray_beta,
100                                  float* vis_cont )
101{
102    float PI = 0.0;
103
104    /* Compute PI for all threads */
105    if (seg_len > 1.0e-10f) {    /* if  too small, do nothing */
106        PI = view_dep_mixture_model(mean_obs, mixture, app_model_weights);
107    }
108
109    //calculate this ray's contribution to beta
110    (*ray_beta) = ((*ray_pre) + PI*(*ray_vis))*seg_len/norm;
111    (*vis_cont) = (*ray_vis) * seg_len;
112
113    //update ray_pre and ray_vis
114    float temp  = exp(-alpha * seg_len);
115
116    /* updated pre                      Omega         *  PI         */
117    (*ray_pre) += (*ray_vis)*(1.0f-temp)*PI;//(image_vect[llid].z - vis_prob_end) * PI;
118    /* updated visibility probability */
119    (*ray_vis) *= temp;
120}
121
122
123//bayes step cell functor
124void step_cell_bayes(AuxArgs aux_args, int data_ptr, uchar llid, float d)
125{
126
127    //slow beta calculation ----------------------------------------------------
128    float  alpha    = aux_args.alpha[data_ptr];
129    MOG_TYPE mixture = aux_args.mog[data_ptr];
130    float8 num_obs = aux_args.num_obs[data_ptr];
131
132    //load aux data
133    int cum_int = aux_args.seg_len[data_ptr];
134#ifdef YUV
135    float4 mean_obs = unpack_yuv(aux_args.mean_obs[data_ptr]);
136#else
137    float4 mean_obs = convert_float4(unpack_uchar4(aux_args.mean_obs[data_ptr])) * 255.0f;
138#endif
139    float cum_len = convert_float(cum_int) / SEGLEN_FACTOR;
140
141    float ray_beta, vis_cont;
142    bayes_ratio_ind_view_based( d*aux_args.linfo->block_len,
143                                 alpha,
144                                 mixture,
145                                 num_obs,
146                                 aux_args.app_model_weights,
147                                 cum_len*aux_args.linfo->block_len,
148                                 mean_obs,
149                                 aux_args.norm,
150                                 aux_args.ray_pre,
151                                 aux_args.ray_vis,
152                                 &ray_beta,
153                                 &vis_cont);
154
155    //discretize and store beta and vis contribution
156    int beta_int = convert_int_rte(ray_beta * SEGLEN_FACTOR);
157    atom_add(&aux_args.beta_array[data_ptr], beta_int);
158    int vis_int  = convert_int_rte(vis_cont * SEGLEN_FACTOR);
159    atom_add(&aux_args.vis_array[data_ptr], vis_int);
160
161
162    //reset cell_ptrs to -1 every time
163    aux_args.cell_ptrs[llid] = -1;
164}
165#endif // BAYES
166