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; }