double guess_EBV_max(TImgStack &img_stack) {
cv::Mat stack, row_avg, col_avg;
// Stack images
img_stack.stack(stack);
// Normalize at each distance
/*cv::reduce(stack, col_avg, 1, CV_REDUCE_MAX);
double tmp;
for(size_t i=0; i<col_avg.rows; i++) {
tmp = col_avg.at<double>(i, 0);
if(tmp > 0) { stack.row(i) /= tmp; }
}*/
// Sum across each EBV
cv::reduce(stack, row_avg, 0, CV_REDUCE_AVG);
double max_sum = *std::max_element(row_avg.begin<double>(), row_avg.end<double>());
int max = 1;
/*for(int i = row_avg.cols - 1; i >= 0; i--) {
std::cout << i << "\t" << row_avg.at<double>(0, i) << std::endl;
}*/
//std::cout << std::endl;
for(int i = row_avg.cols - 1; i > 0; i--) {
//std::cout << i << "\t" << row_avg.at<double>(0, i) << std::endl;
if(row_avg.at<double>(0, i) > 0.001 * max_sum) {
max = i;
break;
}
}
// Convert bin index to E(B-V)
return max * img_stack.rect->dx[1] + img_stack.rect->min[1];
}
// Guess upper limit for E(B-V) based on stacked probability surfaces
double guess_EBV_max(TImgStack &img_stack) {
cv::Mat stack, row_avg, col_avg;
// Stack images
img_stack.stack(stack);
// Sum across each EBV
cv::reduce(stack, row_avg, 0, CV_REDUCE_AVG);
double max_sum = *std::max_element(row_avg.begin<double>(), row_avg.end<double>());
int max = 1;
for(int i = row_avg.cols - 1; i > 0; i--) {
if(row_avg.at<double>(0, i) > 0.001 * max_sum) {
max = i;
break;
}
}
// Convert bin index to E(B-V)
return max * img_stack.rect->dx[1] + img_stack.rect->min[1];
}
void monotonic_guess(TImgStack &img_stack, unsigned int N_regions, std::vector<double>& Delta_EBV, TMCMCOptions& options) {
std::cout << "stacking images" << std::endl;
// Stack images
cv::Mat stack;
img_stack.stack(stack);
std::cout << "calculating weighted mean at each distance" << std::endl;
// Weighted mean of each distance
double * dist_y_sum = new double[stack.rows];
double * dist_y2_sum = new double[stack.rows];
double * dist_sum = new double[stack.rows];
for(int k = 0; k < stack.rows; k++) {
dist_y_sum[k] = 0.;
dist_y2_sum[k] = 0.;
dist_sum[k] = 0.;
}
double y = 0.5;
for(int j = 0; j < stack.cols; j++, y += 1.) {
for(int k = 0; k < stack.rows; k++) {
dist_y_sum[k] += y * stack.at<double>(k,j);
dist_y2_sum[k] += y*y * stack.at<double>(k,j);
dist_sum[k] += stack.at<double>(k,j);
}
}
for(int k = 0; k < stack.rows; k++) {
std::cout << k << "\t" << dist_y_sum[k]/dist_sum[k] << "\t" << sqrt(dist_y2_sum[k]/dist_sum[k]) << "\t" << dist_sum[k] << std::endl;
}
std::cout << "calculating weighted mean about each anchor" << std::endl;
// Weighted mean in region of each anchor point
std::vector<double> y_sum(N_regions+1, 0.);
std::vector<double> y2_sum(N_regions+1, 0.);
std::vector<double> w_sum(N_regions+1, 0.);
int kStart = 0;
int kEnd;
double width = (double)(stack.rows) / (double)(N_regions);
for(int n = 0; n < N_regions+1; n++) {
std::cout << "n = " << n << std::endl;
if(n == N_regions) {
kEnd = stack.rows;
} else {
kEnd = ceil(((double)n + 0.5) * width);
}
for(int k = kStart; k < kEnd; k++) {
y_sum[n] += dist_y_sum[k];
y2_sum[n] += dist_y2_sum[k];
w_sum[n] += dist_sum[k];
}
kStart = kEnd + 1;
}
delete[] dist_sum;
delete[] dist_y_sum;
delete[] dist_y2_sum;
std::cout << "Covert to EBV and sigma_EBV" << std::endl;
// Create non-monotonic guess
Delta_EBV.resize(N_regions+1);
std::vector<double> sigma_EBV(N_regions+1, 0.);
for(int i=0; i<N_regions+1; i++) { Delta_EBV[i] = 0; }
for(int n = 0; n < N_regions+1; n++) {
Delta_EBV[n] = img_stack.rect->min[1] + img_stack.rect->dx[1] * y_sum[n] / w_sum[n];
sigma_EBV[n] = img_stack.rect->dx[1] * sqrt( (y2_sum[n] - (y_sum[n] * y_sum[n] / w_sum[n])) / w_sum[n] );
std::cout << n << "\t" << Delta_EBV[n] << "\t+-" << sigma_EBV[n] << std::endl;
}
// Fit monotonic guess
unsigned int N_steps = 100;
unsigned int N_samplers = 2 * N_regions;
unsigned int N_threads = options.N_threads;
unsigned int ndim = N_regions + 1;
std::cout << "Setting up params" << std::endl;
TEBVGuessParams params(Delta_EBV, sigma_EBV, w_sum, img_stack.rect->max[1]);
TNullLogger logger;
TAffineSampler<TEBVGuessParams, TNullLogger>::pdf_t f_pdf = &lnp_monotonic_guess;
TAffineSampler<TEBVGuessParams, TNullLogger>::rand_state_t f_rand_state = &gen_rand_monotonic;
std::cout << "Setting up sampler" << std::endl;
TParallelAffineSampler<TEBVGuessParams, TNullLogger> sampler(f_pdf, f_rand_state, ndim, N_samplers*ndim, params, logger, N_threads);
sampler.set_scale(1.1);
sampler.set_replacement_bandwidth(0.75);
std::cout << "Stepping" << std::endl;
sampler.step(int(N_steps*40./100.), true, 0., 0.5, 0.);
sampler.step(int(N_steps*10./100), true, 0., 1., 0.);
sampler.step(int(N_steps*40./100.), true, 0., 0.5, 0.);
sampler.step(int(N_steps*10./100), true, 0., 1., 0., true);
sampler.print_stats();
std::cout << "Getting best value" << std::endl;
Delta_EBV.clear();
sampler.get_chain().get_best(Delta_EBV);
std::cout << "Monotonic guess" << std::endl;
double EBV_sum = 0.;
for(size_t i=0; i<Delta_EBV.size(); i++) {
EBV_sum += Delta_EBV[i];
std::cout << EBV_sum << std::endl;
Delta_EBV[i] = log(Delta_EBV[i]);
}
std::cout << std::endl;
}
