void GenerateZLUTFittingCurve(const char *lutfile)
{
QTrkSettings settings;
settings.width = settings.height = 80;
QueuedCPUTracker qt(settings);
ImageData lut = ReadJPEGFile(lutfile);
ImageData nlut;
ResampleLUT(&qt, &lut, lut.h, &nlut);
CPUTracker trk(settings.width,settings.height);
ImageData smp = ImageData::alloc(settings.width,settings.height);
trk.SetRadialZLUT(nlut.data, nlut.h, nlut.w, 1, qt.cfg.zlut_minradius, qt.cfg.zlut_maxradius, false, false);
int N=8;
for (int z=0;z<6;z++) {
vector3f pos(settings.width/2,settings.height/2, nlut.h * (1+z) / (float)N + 0.123f);
GenerateImageFromLUT(&smp, &nlut, qt.cfg.zlut_minradius, qt.cfg.zlut_maxradius, pos);
ApplyPoissonNoise(smp, 10000);
WriteJPEGFile( SPrintf("zlutfitcurve-smpimg-z%d.jpg", z).c_str(), smp);
trk.SetImageFloat(smp.data);
std::vector<float> profile(qt.cfg.zlut_radialsteps), cmpProf(nlut.h), fitted(nlut.h);
trk.ComputeRadialProfile(&profile[0], qt.cfg.zlut_radialsteps, qt.cfg.zlut_angularsteps, qt.cfg.zlut_minradius, qt.cfg.zlut_maxradius, pos.xy(), false);
trk.LUTProfileCompare(&profile[0], 0, &cmpProf[0], CPUTracker::LUTProfMaxQuadraticFit, &fitted[0]);
WriteArrayAsCSVRow("zlutfitcurve-profile.txt", &profile[0], profile.size(), z>0);
WriteArrayAsCSVRow("zlutfitcurve-cmpprof.txt", &cmpProf[0], cmpProf.size(), z>0);
WriteArrayAsCSVRow("zlutfitcurve-fitted.txt", &fitted[0], fitted.size(), z>0);
}
smp.free();
nlut.free();
lut.free();
}
TextureRegion TextureRegion::fitted(const Vec2& _size, const bool scaleUp) const
{
return fitted(_size.x, _size.y, scaleUp);
}
// Calculate the martingale increments using the row rearrangement
//[[Rcpp::export]]
arma::cube AddDual(const arma::cube& path,
Rcpp::NumericVector subsim_,
const arma::vec& weight,
Rcpp::NumericVector value_,
Rcpp::Function Scrap_) {
// R objects to C++
const std::size_t n_path = path.n_rows;
const arma::ivec v_dims = value_.attr("dim");
const std::size_t n_grid = v_dims(0);
const std::size_t n_dim = v_dims(1);
const std::size_t n_pos = v_dims(2);
const std::size_t n_dec = v_dims(3);
const arma::cube value(value_.begin(), n_grid, n_dim * n_pos, n_dec, false);
const arma::ivec s_dims = subsim_.attr("dim");
const std::size_t n_subsim = s_dims(2);
const arma::cube subsim(subsim_.begin(), n_dim, n_dim * n_subsim * n_path, n_dec - 1, false);
// Duals
arma::cube mart(n_path, n_pos, n_dec - 1);
arma::mat temp_state(n_subsim * n_path, n_dim);
arma::mat fitted(n_grid, n_dim);
std::size_t ll;
Rcpp::Rcout << "Additive duals at dec: ";
// Find averaged value
for (std::size_t tt = 0; tt < (n_dec - 2); tt++) {
Rcpp::Rcout << tt << "...";
// 1 step subsimulation
#pragma omp parallel for private(ll)
for (std::size_t ii = 0; ii < n_path; ii++) {
for (std::size_t ss = 0; ss < n_subsim; ss++) {
ll = n_subsim * ii + ss;
temp_state.row(ll) = weight(ss) * path.slice(tt).row(ii) *
arma::trans(subsim.slice(tt).cols(n_dim * ll, n_dim * (ll + 1) - 1));
}
}
// Averaging
for (std::size_t pp = 0; pp < n_pos; pp++) {
fitted = value.slice(tt + 1).cols(n_dim * pp, n_dim * (pp + 1) - 1);
mart.slice(tt).col(pp) = arma::conv_to<arma::vec>::from(arma::sum(arma::reshape(
OptimalValue(temp_state, fitted), n_subsim, n_path)));
// Subtract the path realisation
mart.slice(tt).col(pp) -= OptimalValue(path.slice(tt + 1), fitted);
}
}
// Scrap value
Rcpp::Rcout << n_dec - 1 << "...";
// 1 step subsimulation
#pragma omp parallel for private(ll)
for (std::size_t ii = 0; ii < n_path; ii++) {
for (std::size_t ss = 0; ss < n_subsim; ss++) {
ll = n_subsim * ii + ss;
temp_state.row(n_path * ss + ii) = path.slice(n_dec - 2).row(ii) *
arma::trans(subsim.slice(n_dec - 2).cols(n_dim * ll, n_dim * (ll + 1) - 1));
}
}
// Averaging
arma::mat subsim_scrap(n_subsim * n_path, n_pos);
subsim_scrap = Rcpp::as<arma::mat>(Scrap_(
Rcpp::as<Rcpp::NumericMatrix>(Rcpp::wrap(temp_state))));
arma::mat scrap(n_path, n_pos);
scrap = Rcpp::as<arma::mat>(Scrap_(
Rcpp::as<Rcpp::NumericMatrix>(Rcpp::wrap(path.slice(n_dec - 1)))));
for (std::size_t pp = 0; pp < n_pos; pp++) {
mart.slice(n_dec - 2).col(pp) =
arma::reshape(subsim_scrap.col(pp), n_path, n_subsim) * weight;
// Subtract the path realisation
mart.slice(n_dec - 2).col(pp) -= scrap.col(pp);
}
Rcpp::Rcout << "done\n";
return mart;
}
void MMEstimator::operator()(const Data& data, double* coef_ptr,
double* fitted_ptr, double* resid_ptr,
double* scale_ptr) {
const arma::vec& y = data.y;
const arma::mat& x = data.x;
arma::vec coef(p);
arma::vec fitted(n);
arma::vec resid(n);
double scale;
arma::vec y_wt(n);
arma::mat x_wt(n, p);
arma::vec wt(n);
// S estimation
double scale_prev;
lqs_estimator(data, coef.memptr(), fitted.memptr(), resid.memptr(), &scale);
for (int i = 0; i < 30; i++) {
// calculate weights
wt = resid / scale;
wt.transform(util::psi(k0));
wt = sqrt(wt);
// apply weights to data
y_wt = y % wt;
// TODO: try sparse diagonal matrix multiplication, column-wise dot product
for (int i = 0; i < n; i++) {
x_wt.row(i) = x.row(i) * wt(i);
}
// find weighted least squares estimate
coef = arma::solve(x_wt, y_wt);
resid = y - x * coef;
// re-calculate scale
wt = resid / scale;
wt.transform(util::chi(k0));
scale_prev = scale;
scale *= sqrt(sum(wt) / ((n - p) * beta));
if (fabs(scale / scale_prev - 1) < 1e-5) break;
}
// M estimation
int maxit = 50000;
arma::vec resid_prev(n);
double c = 4.685;
arma::vec conv(1);
for (int i = 0; i < maxit; i++) {
resid_prev = resid;
// calculate weights
wt = resid / scale;
wt.transform(util::psi(c));
wt = sqrt(wt);
// apply weights to data
y_wt = y % wt;
for (int i = 0; i < n; i++) {
x_wt.row(i) = x.row(i) * wt(i);
}
// find weighted least squares estimate
coef = arma::solve(x_wt, y_wt);
resid = y - x * coef;
// check for convergence
conv = sqrt(sum(pow(resid - resid_prev, 2)) / sum(pow(resid_prev, 2)));
if (conv(0) < 1e-4) break;
}
// output
arma::vec coef_out(coef_ptr, p, false, true);
arma::vec fitted_out(fitted_ptr, n, false, true);
arma::vec resid_out(resid_ptr, n, false, true);
arma::vec scale_out(scale_ptr, 1, false, true);
coef_out = coef;
fitted_out = x * coef;
resid_out = resid;
scale_out = scale;
}
