[ Up ]

Irani-Peleg Renderer

ALE implements an iterative image reconstruction algorithm based on Michal Irani and Shmuel Peleg's paper "Improving Resolution by Image Registration", published in Graphical Models and Image Processing, Vol. 53, No. 3, May, pp. 231-239, 1991, or available at:

http://www.wisdom.weizmann.ac.il/~irani/abstracts/superResolution.html

This algorithm iteratively performs two steps: first, an approximation of T is projected, based on a filter approximating d_j, and data collected during alignment, to create a set of simulated input frames; second, the per-pixel error -- between these simulated input frames and the actual input frames -- is calculated, backprojected, and subtracted from the approximation of T, resulting in a new approximation of T.

Initial Image Approximation

ALE uses the results of previous rendering steps as the initial image approximation.

Projection and Back-projection filters

Transformation details

ALE's method of transforming pixel areas between coordinate systems approximates transformed pixel boundaries with axis-aligned rectangular regions. Since boundaries are transformed into the coordinate systems of the input frames, this approximation can be improved by using larger scale factors (and hence reducing the size of transformed pixels).

Multi-level operation

The following is an edited excerpt from the comment headers for the source file d2/render/ipc.h. For more information about ALE's implementation of multi-level operation, see the relevant source files.

 * 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           Binary Operators
 * ---------------------------------------------------------------
 *
 *    scene(n) ------> scene(n+1)        <--- summation
 *
 *      |                 ^
 *      |                 |
 *     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            Binary Operators
 * ---------------------------------------------------------------
 *
 *    scene(n) -----> scene(n+1)          <--- summation
 *
 *      |                 ^
 *      |                 |
 *    LPSF              LPSF'
 *      |                 |
 *      |       ----------+               <--- difference,
 *      V      /          |                    exposure
 *                                             re-estimation
 *  lsimulated(n)      lreal(n)
 *
 *      |                 ^
 *      |                 |
 *   unlinearize       linearize
 *      |                 |
 *      V                 |
 *
 *  lsim_nl(n) -----> lreal_nl(n)         <--- summation
 *
 *      |                 ^
 *      |                 |
 *    NLPSF             NLPSF'
 *      |                 |
 *      |       ----------+               <--- difference
 *      V      /          |
 *
 *  nlsimulated(n)     real_nl
 *
 *                        ^
 *                        |
 *                    unlinearize
 *                        |
 *                        |
 *
 *                      real
 *
 * ===============================================================

Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.