mauro/ale
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
ale/d2/render/ipc.h
Mauro Torrez 47650131de initial commit
2022-07-30 14:46:04 -03:00

1389 lines
33 KiB
C++
Raw Blame History

// Copyright 2003, 2004 David Hilvert <dhilvert@auricle.dyndns.org>,
// <dhilvert@ugcs.caltech.edu>
/* This file is part of the Anti-Lamenessing Engine.
The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the Anti-Lamenessing Engine; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* ipc.h: A render subclass implementing an iterative image reconstruction
* algorithm based on the work of Michal Irani and Shmuel Peleg. The
* projection and backprojection functions used are user-configurable.
* For more information on the theory behind the algorithm, see the last
* section and appendix of:
*
* http://www.wisdom.weizmann.ac.il/~irani/abstracts/superResolution.html
*
* The algorithm in the source paper looks something like this (PSF' is the
* backprojection kernel, and corresponds to what the authors of the paper call
* AUX):
*
* ===============================================================
* Forward Backward Points of comparison
* ---------------------------------------------------------------
*
* scene(n) scene(n+1)
*
* | ^
* | |
* PSF PSF'
* | |
* | ---------+ <--- difference
* V / |
*
* simulated(n) real
*
* ===============================================================
*
* This assumes a single colorspace representation. However, consumer cameras
* sometimes perform sharpening in non-linear colorspace, whereas lens and
* sensor blurring occurs in linear colorspace. Hence, there can be two
* colorspaces involved; ALE accounts for this with linear and non-linear
* colorspace PSFs. Hence, the algorithm we use looks something like:
*
* ===============================================================
* Forward Backward Points of comparison
* ---------------------------------------------------------------
*
* scene(n) scene(n+1)
*
* | ^
* | |
* LPSF LPSF'
* | |
* | ----------+ <--- difference,
* V / | exposure
* re-estimation
* lsimulated(n) lreal
*
* | ^
* | |
* unlinearize linearize
* | |
* V |
*
* lsim_nl(n) lreal_nl(n)
*
* | ^
* | |
* NLPSF NLPSF'
* | |
* | ----------+ <--- difference
* V / |
*
* nlsimulated(n) real_nl
*
* ^
* |
* unlinearize
* |
* |
*
* real
*
* ===============================================================
*/
#ifndef __ipc_h__
#define __ipc_h__
#include "../image.h"
#include "../render.h"
#include "psf/rasterizer.h"
#include "psf/normalizer.h"
#include "psf/backprojector.h"
class ipc : public render {
protected:
int synced;
int inc;
image *approximation;
image *definition;
render *input;
unsigned int iterations;
psf *lresponse, *nlresponse;
int exposure_register;
int use_weighted_median;
double weight_limit;
/*
* Calculate the simulated input frame SIMULATED from the image
* approximation APPROXIMATION, iterating over image approximation
* pixels.
*/
struct sim_args {
int frame_num;
image *approximation;
image *lsimulated;
image *nlsimulated;
image *lsim_weights;
image *nlsim_weights;
transformation t;
const raster *lresponse;
const raster *nlresponse;
const exposure *exp;
point *extents;
sim_args() : t(transformation::eu_identity()) {
}
};
class simulate_linear : public thread::decompose_domain,
private sim_args {
point *subdomain_extents;
protected:
void prepare_subdomains(unsigned int N) {
subdomain_extents = new point[N * 2];
for (unsigned int n = 0; n < N; n++) {
point *se = subdomain_extents + 2 * n;
for (int d = 0; d < 2; d++) {
se[0][d] = extents[0][d];
se[1][d] = extents[1][d];
}
}
}
void subdomain_algorithm(unsigned int thread,
int i_min, int i_max, int j_min, int j_max) {
point *extents = subdomain_extents + thread * 2;
/*
* Linear filtering, iterating over approximation pixels
*/
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++) {
if (is_excluded_r(approximation->offset(), i, j, frame_num))
continue;
/*
* Obtain the position Q and dimensions D of
* image approximation pixel (i, j) in the coordinate
* system of the simulated frame.
*/
point p = point(i + approximation->offset()[0], j + approximation->offset()[1]);
point q;
ale_pos d[2];
/*
* XXX: This appears to calculate the wrong thing.
*/
if (is_excluded_f(p, frame_num))
continue;
t.unscaled_map_area_inverse(p, &q, d);
/*
* Convenient variables for expressing the boundaries
* of the mapped area.
*/
ale_pos top = q[0] - d[0];
ale_pos bot = q[0] + d[0];
ale_pos lef = q[1] - d[1];
ale_pos rig = q[1] + d[1];
/*
* Iterate over all simulated frame pixels influenced
* by the scene pixel (i, j), as determined by the
* response function.
*/
int imin = (int) floor(top + (ale_pos) lresponse->min_i());
int imax = (int) ceil(bot + (ale_pos) lresponse->max_i());
int jmin = (int) floor(lef + (ale_pos) lresponse->min_j());
int jmax = (int) ceil(rig + (ale_pos) lresponse->max_j());
pixel tr = pixel(1, 1, 1) / t.get_tonal_multiplier(p);
for (int ii = imin; ii <= imax; ii++)
for (int jj = jmin; jj <= jmax; jj++) {
if (ii < (int) 0
|| ii >= (int) lsimulated->height()
|| jj < (int) 0
|| jj >= (int) lsimulated->width())
continue;
if (ii < extents[0][0])
extents[0][0] = ii;
if (jj < extents[0][1])
extents[0][1] = jj;
if (ii > extents[1][0])
extents[1][0] = ii;
if (jj > extents[1][1])
extents[1][1] = jj;
class rasterizer::psf_result r =
(*lresponse)(top - ii, bot - ii,
lef - jj, rig - jj,
lresponse->select(ii, jj),
lsimulated->get_channels(ii, jj));
lock();
if (lsimulated->get_bayer() == IMAGE_BAYER_NONE) {
lsimulated->add_pixel(ii, jj,
r(approximation->get_pixel(i, j) * tr));
lsim_weights->add_pixel(ii, jj,
r.weight());
} else {
int k = lsimulated->bayer_color(ii, jj);
lsimulated->add_chan(ii, jj, k,
r(approximation->get_pixel(i, j))[k] * tr[k]);
lsim_weights->add_chan(ii, jj, k,
r.weight()[k]);
}
unlock();
}
}
}
void finish_subdomains(unsigned int N) {
/*
* Determine extents
*/
for (unsigned int n = 0; n < N; n++) {
point *se = subdomain_extents + 2 * n;
for (int d = 0; d < 2; d++) {
if (se[0][d] < extents[0][d])
extents[0][d] = se[0][d];
if (se[1][d] > extents[1][d])
extents[1][d] = se[1][d];
}
}
delete[] subdomain_extents;
}
public:
simulate_linear(sim_args s) : decompose_domain(0, s.approximation->height(),
0, s.approximation->width()),
sim_args(s) {
}
};
class simulate_nonlinear : public thread::decompose_domain,
private sim_args {
point *subdomain_extents;
protected:
void prepare_subdomains(unsigned int N) {
subdomain_extents = new point[N * 2];
for (unsigned int n = 0; n < N; n++) {
point *se = subdomain_extents + 2 * n;
for (int d = 0; d < 2; d++) {
se[0][d] = extents[0][d];
se[1][d] = extents[1][d];
}
}
}
void subdomain_algorithm(unsigned int thread,
int i_min, int i_max, int j_min, int j_max) {
point *extents = subdomain_extents + thread * 2;
/*
* Iterate non-linear
*/
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++) {
/*
* Convenient variables for expressing the boundaries
* of the mapped area.
*/
ale_pos top = i - 0.5;
ale_pos bot = i + 0.5;
ale_pos lef = j - 0.5;
ale_pos rig = j + 0.5;
/*
* Iterate over all simulated frame pixels influenced
* by the scene pixel (i, j), as determined by the
* response function.
*/
for (int ii = (int) floor(top + (ale_pos) nlresponse->min_i());
ii <= ceil(bot + (ale_pos) nlresponse->max_i()); ii++)
for (int jj = (int) floor(lef + (ale_pos) nlresponse->min_j());
jj <= ceil(rig + (ale_pos) nlresponse->max_j()); jj++) {
if (ii < (int) 0
|| ii >= (int) nlsimulated->height()
|| jj < (int) 0
|| jj >= (int) nlsimulated->width())
continue;
if (ii < extents[0][0])
extents[0][0] = ii;
if (jj < extents[0][1])
extents[0][1] = jj;
if (ii > extents[1][0])
extents[1][0] = ii;
if (jj > extents[1][1])
extents[1][1] = jj;
class rasterizer::psf_result r =
(*nlresponse)(top - ii, bot - ii,
lef - jj, rig - jj,
nlresponse->select(ii, jj));
lock();
nlsimulated->add_pixel(ii, jj,
r(exp->unlinearize(lsimulated->get_pixel(i, j))));
nlsim_weights->add_pixel(ii, jj,
r.weight());
unlock();
}
}
}
void finish_subdomains(unsigned int N) {
/*
* Determine extents
*/
for (unsigned int n = 0; n < N; n++) {
point *se = subdomain_extents + 2 * n;
for (int d = 0; d < 2; d++) {
if (se[0][d] < extents[0][d])
extents[0][d] = se[0][d];
if (se[1][d] > extents[1][d])
extents[1][d] = se[1][d];
}
}
delete[] subdomain_extents;
}
public:
simulate_nonlinear(sim_args s) : decompose_domain(0, s.lsimulated->height(),
0, s.lsimulated->width()),
sim_args(s) {
}
};
void _ip_frame_simulate(int frame_num, image *approximation,
image *lsimulated, image *nlsimulated,
transformation t, const raster *lresponse,
const raster *nlresponse, const exposure &exp,
point *extents) {
sim_args args;
/*
* Initializations for linear filtering
*/
image *lsim_weights = NULL;
if (lsimulated->get_bayer() == IMAGE_BAYER_NONE) {
lsim_weights = new_image_ale_real(
lsimulated->height(),
lsimulated->width(),
lsimulated->depth());
} else {
lsim_weights = new_image_bayer_ale_real(
lsimulated->height(),
lsimulated->width(),
lsimulated->depth(),
lsimulated->get_bayer());
}
assert (lsim_weights);
args.frame_num = frame_num;
args.approximation = approximation;
args.lsimulated = lsimulated;
args.nlsimulated = nlsimulated;
args.lsim_weights = lsim_weights;
args.t = t;
args.lresponse = lresponse;
args.nlresponse = nlresponse;
args.exp = &exp;
args.extents = extents;
/*
* Simulate linear
*/
simulate_linear sl(args);
sl.run();
/*
* Normalize linear
*/
for (unsigned int ii = 0; ii < lsimulated->height(); ii++)
for (unsigned int jj = 0; jj < lsimulated->width(); jj++) {
const ale_real weight_floor = ale_real_ip_weight_floor;
ale_accum zero = 0;
for (int k = 0; k < 3; k++) {
if ((lsimulated->get_channels(ii, jj) & (1 << k)) == 0)
continue;
ale_real weight = lsim_weights->get_chan(ii, jj, k);
if (!(weight > weight_floor))
lsimulated->div_chan(ii, jj, k,
zero); /* Generate a non-finite value */
else
lsimulated->div_chan(ii, jj, k,
weight);
}
}
/*
* Finalize linear
*/
delete lsim_weights;
/*
* Return if there is no non-linear step.
*/
if (nlsimulated == NULL) {
return;
}
/*
* Initialize non-linear
*/
image *nlsim_weights = new_image_ale_real(
nlsimulated->height(),
nlsimulated->width(),
nlsimulated->depth());
args.nlsim_weights = nlsim_weights;
/*
* Simulate non-linear
*/
simulate_nonlinear snl(args);
snl.run();
/*
* Normalize non-linear
*/
for (unsigned int ii = 0; ii < nlsimulated->height(); ii++)
for (unsigned int jj = 0; jj < nlsimulated->width(); jj++) {
pixel weight = nlsim_weights->get_pixel(ii, jj);
ale_real weight_floor = ale_real_ip_weight_floor;
ale_accum zero = 0;
for (int k = 0; k < 3; k++)
if (!(weight[k] > weight_floor))
nlsimulated->div_chan(ii, jj, k,
zero); /* Generate a non-finite value */
nlsimulated->div_pixel(ii, jj, weight);
}
/*
* Finalize non-linear
*/
delete nlsim_weights;
}
struct correction_t {
/*
* Type
*/
int use_weighted_median;
/*
* Weighted Median
*/
image_weighted_median *iwm;
/*
* Weight limit
*/
double weight_limit;
/*
* Common
*/
image *c;
image *cc;
/*
* Create correction structures.
*/
correction_t(int use_weighted_median, double weight_limit, unsigned int h, unsigned int w, unsigned int d) {
this->use_weighted_median = use_weighted_median;
if (use_weighted_median)
iwm = new image_weighted_median(h, w, d);
this->weight_limit = weight_limit;
c = new_image_ale_real(h, w, d);
cc = new_image_ale_real(h, w, d);
}
/*
* Destroy correction structures
*/
~correction_t() {
if (use_weighted_median)
delete iwm;
delete c;
delete cc;
}
/*
* Correction count
*/
pixel get_count(int i, int j) {
if (use_weighted_median)
return iwm->get_weights()->get_pixel(i, j);
else
return cc->get_pixel(i, j);
}
/*
* Check for weight limit
*/
int weight_limited(int i, int j) {
if (weight_limit
&& get_count(i, j)[0] >= weight_limit
&& get_count(i, j)[1] >= weight_limit
&& get_count(i, j)[2] >= weight_limit)
return 1;
return 0;
}
/*
* Correction value
*/
pixel get_correction(int i, int j) {
if (use_weighted_median)
return iwm->get_colors()->get_pixel(i, j);
else
return (pixel) c->get_pixel(i, j)
/ (pixel) cc->get_pixel(i, j);
}
/*
* Frame end
*/
void frame_end(int frame_num) {
if (use_weighted_median) {
for (unsigned int i = 0; i < c->height(); i++)
for (unsigned int j = 0; j < c->width(); j++) {
/*
* Update the median calculator
*/
pixel cval = c->get_pixel(i, j);
pixel ccval = cc->get_pixel(i, j);
iwm->accumulate(i, j, frame_num, cval / ccval, ccval);
/*
* Reset the counters
*/
c->set_pixel(i, j, pixel::zero());
cc->set_pixel(i, j, pixel::zero());
}
}
}
/*
* Update correction structures, using either a weighted mean update or
* a weighted median update.
*/
void update(int i, int j, pixel value_times_weight, pixel weight) {
c->add_pixel(i, j, value_times_weight);
cc->add_pixel(i, j, weight);
}
};
/*
* For each pixel in APPROXIMATION, calculate the differences
* between SIMULATED and REAL pixels influenced by this pixel,
* and back-project the differences onto the correction array
* C. The number of frames backprojected to each pixel in C is
* counted in CC.
*
* Since APPROXIMATION can always, given sufficient computational
* resources, be configured to be of finer resolution than SIMULATED,
* we map APPROXIMATION pixels onto the SIMULATED grid rather than vice
* versa. This should reduce the error incurred by approximations in
* d2::transformation::unscaled_map_area*().
*
* This approach requires multiplying the resultant integral by a
* corrective factor, since the grids are generally of different
* densities.
*/
struct correct_args {
int frame_num;
image *approximation;
correction_t *cu;
const image *real;
image *lreal;
image *lsimulated;
image *nlsimulated;
transformation t;
const backprojector *lresponse;
const backprojector *nlresponse;
double weight_limit;
correct_args() : t(transformation::eu_identity()) {
}
};
class correct_nonlinear : public thread::decompose_domain,
private correct_args {
protected:
void subdomain_algorithm(unsigned int thread,
int i_min, int i_max, int j_min, int j_max) {
/*
* Unlinearize values from lsimulated.
*/
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++)
lreal->set_pixel(i, j, real->exp().unlinearize(
lsimulated->get_pixel(i, j)));
/*
* Backproject from real to lreal, iterating over all pixels
* in lreal.
*/
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++) {
/*
* XXX: Is this right?
*/
if (is_excluded_r(approximation->offset(), i, j, frame_num))
continue;
/*
* Convenient variables for expressing the boundaries
* of the mapped area.
*/
ale_pos top = i - 0.5;
ale_pos bot = i + 0.5;
ale_pos lef = j - 0.5;
ale_pos rig = j + 0.5;
/*
* Iterate over non-linear pixels influenced by linear
* pixels.
*/
for (int ii = (int) floor(top + (ale_pos) nlresponse->min_i());
ii <= ceil(bot + (ale_pos) nlresponse->max_i()); ii++)
for (int jj = (int) floor(lef + (ale_pos) nlresponse->min_j());
jj <= ceil(rig + (ale_pos) nlresponse->max_j()); jj++) {
if (ii < (int) 0
|| ii >= (int) nlsimulated->height()
|| jj < (int) 0
|| jj >= (int) nlsimulated->width())
continue;
class backprojector::psf_result r =
(*nlresponse)(top - ii, bot - ii,
lef - jj, rig - jj,
nlresponse->select(ii, jj));
pixel comp_real =
real->exp().unlinearize(real->get_pixel(ii, jj));
pixel comp_simu =
nlsimulated->get_pixel(ii, jj);
if (!finite(comp_simu[0])
|| !finite(comp_simu[1])
|| !finite(comp_simu[2]))
continue;
/*
* Backprojection value.
*/
pixel bpv = r(comp_real - comp_simu);
/*
* Error calculation
*/
lreal->add_pixel(i, j, bpv);
}
}
/*
* Linearize lreal.
*/
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++)
lreal->set_pixel(i, j, real->exp().linearize(
lreal->get_pixel(i, j)));
}
public:
correct_nonlinear(correct_args c) : decompose_domain(0, c.lreal->height(),
0, c.lreal->width()),
correct_args(c) {
}
};
class correct_linear : public thread::decompose_domain,
private correct_args {
protected:
void subdomain_algorithm(unsigned int thread,
int i_min, int i_max, int j_min, int j_max) {
/*
* Iterate over all pixels in the approximation.
*/
for (int i = i_min; i < i_max; i++)
for (int j = j_min; j < j_max; j++) {
/*
* Check correction count against any weight limit.
*/
if (cu->weight_limited(i, j))
continue;
/*
* Obtain the position Q and dimensions D of image
* approximation pixel (i, j) in the coordinate system
* of the simulated (and real) frame.
*/
point p = point(i + approximation->offset()[0], j + approximation->offset()[1]);
point q;
ale_pos d[2];
t.unscaled_map_area_inverse(p, &q, d);
/*
* Convenient variables for expressing the boundaries
* of the mapped area.
*/
ale_pos top = q[0] - d[0];
ale_pos bot = q[0] + d[0];
ale_pos lef = q[1] - d[1];
ale_pos rig = q[1] + d[1];
ale_pos integral_divisor = 1 / ((bot - top) * (rig - lef));
/*
* Iterate over frame pixels influenced by the scene
* pixel.
*/
int imin = (int) floor(top + (ale_pos) lresponse->min_i());
int imax = (int) ceil(bot + (ale_pos) lresponse->max_i());
int jmin = (int) floor(lef + (ale_pos) lresponse->min_j());
int jmax = (int) ceil(rig + (ale_pos) lresponse->max_j());
pixel tr = t.get_tonal_multiplier(p);
for (int ii = imin; ii <= imax; ii++)
for (int jj = jmin; jj <= jmax; jj++) {
if (ii < (int) 0
|| ii >= (int) lreal->height()
|| jj < (int) 0
|| jj >= (int) lreal->width())
continue;
if (is_excluded_f(ii, jj, frame_num))
continue;
unsigned int selection = lresponse->select(ii, jj);
char channels = lreal->get_channels(ii, jj);
class backprojector::psf_result r =
(*lresponse)(top - ii, bot - ii,
lef - jj, rig - jj,
selection, channels);
/*
* R is the result of integration in the
* coordinate system of the simulated frame.
* We must rescale to get the result of
* integration in the coordinate system of the
* approximation image.
*/
r *= integral_divisor;
pixel comp_lreal =
lreal->get_raw_pixel(ii, jj);
// pixel comp_real =
// real->get_pixel(ii, jj);
pixel comp_simu =
lsimulated->get_raw_pixel(ii, jj);
#if 1
/*
* Under the assumption that finite() testing
* may be expensive, limit such tests to active
* channels.
*/
int found_nonfinite = 0;
for (int k = 0; k < 3; k++) {
if (((1 << k) & channels)
&& (!finite(comp_simu[k])
|| !finite(comp_lreal[k]))) {
found_nonfinite = 1;
break;
}
}
if (found_nonfinite)
continue;
#else
if (!finite(comp_simu[0])
|| !finite(comp_simu[1])
|| !finite(comp_simu[2])
|| !finite(comp_lreal[0])
|| !finite(comp_lreal[1])
|| !finite(comp_lreal[2]))
continue;
#endif
/*
* Backprojection value unadjusted
* for confidence.
*/
pixel bpv = tr * r(comp_lreal - comp_simu);
/*
* Confidence [equal to (1, 1, 1) when
* confidence is uniform].
*/
// Ordinary certainty
// pixel conf = real->exp().confidence(comp_lreal);
// One-sided certainty
// pixel conf = real->exp().one_sided_confidence(comp_lreal, bpv);
// conf = real->exp().one_sided_confidence(comp_real, bpv);
// Estimate-based certainty
// pixel conf = real->exp().confidence(comp_simu);
// One-sided estimate-based certainty
pixel conf = real->exp().one_sided_confidence(comp_simu, bpv);
// One-sided approximation-based certainty
// pixel conf = real->exp().one_sided_confidence(approximation->pix(i, j), bpv);
/*
* If a color is bayer-interpolated, then we have no confidence in its
* value.
*/
if (real->get_bayer() != IMAGE_BAYER_NONE) {
int color = real->bayer_color(ii, jj);
conf[(color + 1) % 3] = 0;
conf[(color + 2) % 3] = 0;
}
/*
* Error calculation
*/
// c->pix(i, j) += bpv * conf;
/*
* Increment the backprojection weight. When
* confidence is uniform, this should weight
* each frame's correction equally.
*/
// cc->pix(i, j) += conf * r.weight()
// / lresponse->integral(selection);
cu->update(i, j, bpv * conf, conf * r.weight() / lresponse->integral(selection));
}
}
}
public:
correct_linear(correct_args c) : decompose_domain(0, c.approximation->height(),
0, c.approximation->width()),
correct_args(c) {
}
};
void _ip_frame_correct(int frame_num, image *approximation,
correction_t *cu, const image *real, image *lsimulated,
image *nlsimulated, transformation t,
const backprojector *lresponse,
const backprojector *nlresponse, point *extents) {
correct_args args;
args.frame_num = frame_num;
args.approximation = approximation;
args.cu = cu;
args.real = real;
args.lsimulated = lsimulated;
args.nlsimulated = nlsimulated;
args.t = t;
args.lresponse = lresponse;
args.nlresponse = nlresponse;
/*
* Generate the image to compare lsimulated with.
*/
const image *lreal;
if (nlsimulated == NULL)
lreal = real;
else {
image *new_lreal = new_image_ale_real(
real->height(),
real->width(),
real->depth(),
"IPC lreal",
&real->exp());
args.lreal = new_lreal;
correct_nonlinear cn(args);
cn.run();
lreal = new_lreal;
}
/*
* Perform exposure adjustment.
*/
if (exposure_register) {
pixel ec;
#if 0
ec = lsimulated->avg_channel_magnitude()
/ lreal->avg_channel_magnitude();
#elsif 0
pixel_accum ratio_sum;
pixel_accum weight_sum;
for (unsigned int i = 0; i < lreal->height(); i++)
for (unsigned int j = 0; j < lreal->width(); j++) {
pixel s = lsimulated->get_pixel(i, j);
pixel r = lreal->get_pixel(i, j);
pixel confidence = real->exp().confidence(r);
if (s[0] > 0.001
&& s[1] > 0.001
&& s[2] > 0.001
&& r[0] > 0.001
&& r[1] > 0.001
&& r[2] > 0.001) {
ratio_sum += confidence * s / r;
weight_sum += confidence;
}
}
ec = ratio_sum / weight_sum;
#else
pixel_accum ssum, rsum;
// for (unsigned int i = 0; i < lreal->height(); i++)
// for (unsigned int j = 0; j < lreal->width(); j++) {
for (unsigned int i = (unsigned int) floor(extents[0][0]);
i < (unsigned int) ceil(extents[1][0]); i++)
for (unsigned int j = (unsigned int) floor(extents[0][1]);
j < (unsigned int) ceil(extents[1][1]); j++) {
if (real->get_bayer() != IMAGE_BAYER_NONE) {
int color = real->bayer_color(i, j);
ale_real s = lsimulated->get_chan(i, j, color);
ale_real r = lreal->get_chan(i, j, color);
if (!finite(s)
|| !finite(r))
continue;
ale_real confidence = real->exp().confidence(color, s);
ssum[color] += confidence * s;
rsum[color] += confidence * r;
} else {
pixel s = lsimulated->get_pixel(i, j);
pixel r = lreal->get_pixel(i, j);
if (!s.finite()
|| !r.finite())
continue;
pixel confidence = real->exp().confidence(s);
ssum += confidence * s;
rsum += confidence * r;
}
}
ec = ssum / rsum;
#endif
if (ec.finite()
&& (ale_accum) 1000 * rsum[0] > (ale_accum) 1
&& (ale_accum) 1000 * rsum[1] > (ale_accum) 1
&& (ale_accum) 1000 * rsum[2] > (ale_accum) 1)
real->exp().set_multiplier(
real->exp().get_multiplier() * ec);
}
args.lreal = (d2::image *) lreal;
correct_linear cl(args);
cl.run();
if (nlsimulated)
delete lreal;
}
/*
* Adjust correction array C based on the difference between the
* simulated projected frame and real frame M. Update the correction
* count CC for affected pixels in C.
*/
virtual void _ip_frame(int frame_num, correction_t *cu, const image *real,
transformation t, const raster *f, const backprojector *b,
const raster *nlf, const backprojector *nlb) {
ui::get()->d2_irani_peleg_start();
ale_accum_disable_casting();
ale_pos_disable_casting();
ale_real_disable_casting();
/*
* Initialize simulated data structures
*/
image *lsimulated;
if (real->get_bayer() == IMAGE_BAYER_NONE) {
lsimulated = new_image_ale_real(
real->height(),
real->width(),
real->depth());
} else {
lsimulated = new_image_bayer_ale_real(
real->height(),
real->width(),
real->depth(),
real->get_bayer());
}
image *nlsimulated = NULL;
if (nlf)
nlsimulated = new_image_ale_real(
real->height(),
real->width(),
real->depth());
/*
* Create simulated frames with forward projection.
*/
ui::get()->ip_frame_simulate_start();
point extents[2] = { point::posinf(), point::neginf() };
_ip_frame_simulate(frame_num, approximation, lsimulated, nlsimulated, t, f, nlf, real->exp(), extents);
/*
* Update the correction array using backprojection.
*/
ui::get()->ip_frame_correct_start();
_ip_frame_correct(frame_num, approximation, cu, real, lsimulated, nlsimulated, t, b, nlb, extents);
/*
* Finalize data structures.
*/
delete lsimulated;
delete nlsimulated;
ale_accum_enable_casting();
ale_pos_enable_casting();
ale_real_enable_casting();
ui::get()->d2_irani_peleg_stop();
}
/*
* Iterate _ip_frame() over all frames, and update APPROXIMATION after
* corrections from all frames have been summed. Repeat for the number
* of iterations specified by the user.
*/
virtual void _ip() {
/*
* Create rasterized PSF and backprojection kernel AUX.
*/
raster **f = (raster **) malloc(image_rw::count() * sizeof(raster *));
backprojector **b = (backprojector **) malloc(image_rw::count() * sizeof(backprojector *));
for (unsigned int m = 0; m < image_rw::count(); m++) {
if (!align::match(m))
continue;
transformation t = align::of(m);
f[m] = new normalizer(new rasterizer(lresponse, t));
b[m] = new backprojector(f[m]);
}
raster *nlf = NULL;
backprojector *nlb = NULL;
if (nlresponse) {
nlf = new normalizer(new rasterizer(nlresponse, transformation::eu_identity()));
nlb = new backprojector(nlf);
}
for (unsigned int n = 0; n < iterations; n++) {
correction_t *correction = new correction_t(
use_weighted_median,
weight_limit,
approximation->height(),
approximation->width(),
approximation->depth());
/*
* Iterate over all frames
*/
for (unsigned int m = 0; m < image_rw::count(); m++) {
if (!align::match(m))
continue;
ui::get()->ip_frame_start(m);
transformation t = align::of(m);
const image *real = image_rw::open(m);
_ip_frame(m, correction, real,
t, f[m], b[m], nlf, nlb);
image_rw::close(m);
correction->frame_end(m);
}
/*
* Update the approximation.
*/
ui::get()->ip_update();
for (unsigned int i = 0; i < approximation->height(); i++)
for (unsigned int j = 0; j < approximation->width(); j++) {
pixel cpix = correction->get_correction(i, j);
pixel ccpix = correction->get_count(i, j);
pixel apix = approximation->get_pixel(i, j);
for (unsigned int k = 0; k < 3; k++) {
const ale_real cc_floor = 1e-20;
if (ccpix[k] < cc_floor)
continue;
if (!finite(cpix[k]))
continue;
if (!finite(apix[k]))
continue;
ale_real new_value = cpix[k] + apix[k];
assert (finite(apix[k]));
assert (finite(ccpix[k]));
assert (finite(cpix[k]));
assert (finite(new_value));
/*
* Negative light doesn't make sense.
*/
if (new_value < 0)
new_value = 0;
approximation->set_chan(i, j, k, new_value);
}
}
delete correction;
if (inc) {
ui::get()->ip_write();
image_rw::output(approximation);
}
ui::get()->ip_step_done();
}
for (unsigned int m = 0; m < image_rw::count(); m++) {
if (!align::match(m))
continue;
delete f[m];
delete b[m];
}
free(f);
free(b);
delete nlf;
delete nlb;
}
public:
ipc(render *input, unsigned int iterations, int _inc, psf *lresponse,
psf *nlresponse, int exposure_register,
int use_weighted_median, double ipwl) {
this->input = input;
synced = 0;
inc = _inc;
this->iterations = iterations;
this->lresponse = lresponse;
this->nlresponse = nlresponse;
this->exposure_register = exposure_register;
this->use_weighted_median = use_weighted_median;
this->weight_limit = ipwl;
}
const image *get_image() const {
if (synced)
return approximation;
else
return input->get_image();
}
const image *get_defined() const {
if (synced) {
assert(0); /* definition is not set */
return definition;
} else
return input->get_defined();
}
void sync(int n) {
render::sync(n);
input->sync(n);
}
void step() {
return;
}
virtual int sync() {
input->sync();
synced = 1;
approximation = input->get_image()->clone("IPC Approximation");
// definition = input->get_defined()->clone("IPC Definition");
optimizations::ip_sources_obtained(this);
ui::get()->ip_start();
_ip();
ui::get()->ip_done();
/*
* Since we write output internally for --inc, no external
* update is necessary in this case.
*/
return 0;
}
virtual ~ipc() {
}
void free_memory() {
}
};
#endif
Reference in New Issue View Git Blame Copy Permalink