3. Dématriçage basé sur l'estimation locale d'un gradient

<< Dématriçage par interpolation bilinéaire | Liste des exercices | >>

Introduction

L'algorithme de dématriçage proposé par Hamilton & Adams [ HA97 ] a été exposé en cours. Nous allons l'utiliser pour estimer le plan $G$, puis estimer les plans $R$ et $B$ par interpolation bilinéaire. Nous comparerons enfin le résultat obtenu avec celui fourni par l'interpolation bilinéaire pour les trois plans.

Remarque : en réalité, l'algorithme original de Hamilton & Adams utilise également un gradient local pour les plans $R$ et $B$.

Implémentation de la méthode

  1. Sur le modèle du plugin écrit au premier exercice, écrire les méthodes setup et run d'un nouveau plugin demat_ha.java. Ce plugin accepte en entrée une image CFA en niveaux de gris sur 8 bits et, dans sa méthode run, il génère l'image estimée en stockant ses 3 plans dans une pile d'images 8 bits :
    • un plan $R$ estimé par interpolation bilinéaire à partir des échantillons de l'image CFA. Pour réaliser cela, réutiliser la méthode cfa_samples écrite au second exercice et procéder par convolution dans le plugin lui-même (plutôt que dans une macro séparée) :
// Déclaration d'un noyau et d'un objet Convolver pour la convolution
float[] kernel = {1,2,1 , 2,4,2 , 1,2,1};
for (int i=0;i<kernel.length;i++) {
    kernel[i]=kernel[i]/4;
}
ImageProcessor red = cfa_samples(ip,0);
Convolver conv = new Convolver();
conv.setNormalize(false);	// SANS normalisation (par défaut, convolve() normalise)
// Composante R estimée par interpolation bilinéaire grâce à la convolution
conv.convolve(red,kernel,3,3);
  • un plan $G$ estimé par la méthode de Hamilton & Adams, en invoquant la méthode est_G_hamilton qui sera écrite à la question suivante ;
  • un plan $B$ estimé comme le plan $R$.
  1. Écrire la méthode
ImageProcessor est_G_hamilton(ImageProcessor cfa_ip) {
    /* à compléter */
    return (est_ip);
}

qui estime le plan $G$ par la méthode de Hamilton & Adams (toujours en considérant le CFA G-R-G). Pour cela, il est possible de recopier a priori tous les échantillons de l'image CFA :

ImageProcessor est_ip = cfa_ip.duplicate();

et de ne modifier ensuite que les échantillons $R$ et $B$ pour y calculer $G$ selon les formules de l'algorithme. Il est aussi rappelé ici que la lecture de la valeur d'un pixel dans une image en niveaux de gris sur 8 bits nécessite un masquage pour éliminer le bit de signe ; par exemple :

int pixel_g = cfa_ip.getPixel(x-1,y)&0xff;

Évaluation de la qualité de l'image estimée

  1. Comparer le plan vert ainsi estimé à celui obtenu par interpolation bilinéaire. Cette comparaison peut être uniquement visuelle ou se baser sur le calcul du rapport signal-sur-bruit pic-à-pic ($PSNR$) du plan vert.
  2. Comparer l'image couleur ainsi estimée à celle obtenue (à l'exercice 2) par interpolation bilinéaire des trois composantes couleur. L'estimation du seul plan vert par cette méthode permet-elle d'obtenir une image couleur satisfaisante ?

Amélioration de l'estimation des plans $R$ et $B$ (facultatif)

Pour améliorer l'estimation des plans $R$ et $B$, il nous faut appliquer l'algorithme de Hamilton et Adams également sur ces composantes.

Considérons le cas de la composante $R$, celui de $B$ étant traité de manière identique. Trois configurations différentes se présentent, pour lesquelles la composante $R$ doit être estimée au pixel central :

- pour la structure {$RGR$}, la formule d'interpolation est : $\hat{R}=(R_{-1,0}+R_{1,0})/2+(2G-\hat{G}_{-1,0}-\hat{G}_{1,0})/2$.

- pour la structure {$BGB$}, la formule d'interpolation est : $\hat{R}=(R_{0,-1}+R_{0,1})/2+(2G-\hat{G}_{0,-1}-\hat{G}_{0,1})/2$.

- pour la structure {$GBG$}, on calcule d'abord les 2 gradients diagonaux :

$\Delta^{x'}=|R_{1,-1}-R_{-1,1}|+|2\hat{G}-\hat{G}_{1,-1}-\hat{G}_{-1,1}|$

$\Delta^{y'}=|R_{-1,-1}-R_{1,1}|+|2\hat{G}-\hat{G}_{-1,-1}-\hat{G}_{1,1}|$

et la formule d'interpolation de $\hat{R}$ est alors :

$(R_{−1,−1}+R_{1,1})/2+(2\hat{G}-\hat{G}_{-1,-1}-\hat{G}_{1,1})/2 $ si $\Delta^{x'}>\Delta^{y'}$,

$(R_{1,−1}+R_{-1,1})/2+(2\hat{G}-\hat{G}_{1,-1}-\hat{G}_{-1,1})/2 $ si $\Delta^{x'}<\Delta^{y'}$,

$(R_{-1,−1}+R_{1,−1}+R_{-1,1}+R_{1,1})/4+(4\hat{G}-\hat{G}_{-1,-1}-\hat{G}_{1,-1}-\hat{G}_{-1,1}-\hat{G}_{1,1})/4 $ si $\Delta^{x'}=\Delta^{y'}$.

  1. Écrire la méthode
ImageProcessor est_RB_hamilton(ImageProcessor cfa_ip, ImageProcessor g_ip, int channel) {
    ImageProcessor est_ip = cfa_ip.duplicate(); // Recopie des échantillons R et B
    /* à compléter */
    return (est_ip);
}

qui estime le plan $R$ ou $B$ (selon la valeur du paramètre channel) selon les formules ci-dessus, le plan $G$ estimé au préalable étant donné dans le paramètre g_ip.

  1. Compléter la méthode de Hamilton & Adams en estimant les plans $R$ et $B$ par appels à la méthode est_RB_hamilton (on pourra stocker les 3 plans couleur dans une pile puis créer l'image couleur par appel à la commande Stack to RGB). Comparer l'image couleur ainsi estimée à celles obtenues précédemment.

Référence

[HA97] John F. Hamilton et James E.Adams, "Adaptive color plan interpolation in single color electronic camera", U.S. Patent 5.506.619.