ALE Image Processing Software Deblurring, Anti-aliasing, and Superresolution. Local Operation localhost 5393119533

[ 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 dj, 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

ALE provides command-line options for selecting forward-projection filters, including box filters (release 0.4.2 and later) and custom filters (release 0.4.7 and later). The back-projection filters are constructed from the forward-projection filters in such a way that condition (9) from Theorem 4.1 in the source paper is satisfied.

## 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
     *
     * ===============================================================

Copyright 2003, 2004 David Hilvert

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