GUITTON Gilles Janvier 2006

LAUGIER Vincent ENST Bretagne

3ième année, filière 4

Projet applicatif (P1)

Sujet n°24 : détection de contours en imagerie radar

Ce projet applicatif vise à implémenter un algorithme de détection de

contours pour images radar de type SAR, à partir de l’article de recherche R.
Touzi, A. Lopes and P. Bousquet, « A statistical and geometrical edge
detector for SAR images », IEEE Trans. Geosci. Remote Sensing, vol. 26,
no. 6, November 1988.

Cet algorithme sera testé sur une image réelle SAR ainsi que sur une
image de synthèse obtenue à partir de générations de pixels suivant deux lois
gamma différentes.

Le présent document est organisé comme suit :

I. Approche théorique p.2

I.1) Le bruit de speckle p.2
I.2) Détection de contours par gradient / ratio p.4

II. Approche pratique p.6

II.1) Algorithme p.6
II.2) Implémentation et fonctions matlab p.9

III. Résultats p.10

III.1) Image réelle p.10
III.2) Image de synthèse p.13

Annexe p.15

1/21
I. Approche théorique

Le radar à synthèse d'ouverture synthétique (SAR) est embarqué sur les

satellites de télédétection depuis la reconnaissance de la qualité des images
obtenues par Seasat. Rappelons de manière succincte les avantages et les
inconvénients d'un système SAR.

Ses avantages sont :

1. son service tout temps indépendant de la couverture nuageuse
2. sa sensibilité à la fois à la nature et à la structure de la zone observée, en
relation avec la longueur d’ondes utilisée et la polarisation choisie.

Ses inconvénients sont :

1. le traitement complexe du signal reçu afin de produire une image
2. la présence d’un bruit de speckle, dû à la nature cohérente du signal émis
3. l’analyse monospectrale.

On s'intéresse dans le cadre de ce projet au problème de la détection de

contours dans le cas d'un bruit de speckle. On commencera par rappeler de
manière succincte le principe du bruit de speckle. On comparera ensuite de
manière théorique deux approches possibles de la détection de contours dans
une image sujette à ce bruit : l'approche classique par le calcul du gradient et
l'approche par le calcul du ratio des puissances moyennes sur les zones
contiguës à un pixel candidat, proposée par Touzi, Lopes et Bousquet.

I.1) Le bruit de speckle

On peut résumer l'idée du bruit de speckle comme une conséquence

indésirable de la combinaison des ondes réfléchies de l'onde cohérente
incidente (en rouge sur la figure 1) par différents points de la surface du sol
(appelés réflecteurs et représentés en vert sur la figure1 ).

Fig. 1: réflections multiples d'une onde cohérente R

2/21
 Ces ondes réfléchies sont caractérisées par une amplitude a k et un
angle de réflexion  k .
N
Pour N réflecteurs le signal reçu (figure 2) sera donc : a.e = ∑ a . e j   . k
k
k=1

Fig. 2: composition du signal réfléchi

La combinaison des ondes réfléchies peut alors être destructive ou constructive

(figure 3).

Fig. 3: combinaison destructive et constructive des ondes réfléchies

Ce phénomène de combinaison constructive ou destructive se concrétise

au niveau de l'image par des pixels dont la valeur de gris est très éloignée de
celle attendue donnant une image à l'aspect granulaire. Ce bruit perturbe alors
la lisibilité des contours. II peut être modélisé par un bruit multiplicatif qui suit
une loi Gamma de paramètre N correspondant au cas particulier d'une loi
Gamma où le second paramètre est nul. La racine carré de la somme de N
variables aléatoires normales suit cette loi. On obtient alors un modèle pour une
image de la forme suivante :

I=S.Z

où I est l’intensité de l’image, Z le bruit et S le coefficient de rétro-diffusion du

sol.

3/21
 La puissance d'un pixel X, sur une zone homogène de puissance moyenne
P0 aura alors pour fonction de vraisemblance :

   
−L
1 P0 L−1 −xL
p x / P0 = x exp (1)
  L L P0

où  . est la fonction gamma et L est le nombre de vues de l’image

et avec E [ X ]=P0 , Var [ X ]=PO 2 / L .

On effectue donc généralement un pré-traitement de ces images SAR afin de

supprimer le bruit avant de se lancer dans l'extraction de l'information de
l'image (détection de contours, analyse de la corrélation, etc). Parmi les
méthodes les plus connues on retrouve le filtrage médian, la linéarisation
logarithmique, le filtrage de Lee et ses dérivés.

I.2) Détection directe de contours sur une image sujette à un bruit

de speckle : approche gradient – approche ratio

On s'intéresse ici à l'extraction directe d'information à partir de l'image

bruitée. On peut en effet vouloir pour diverses raisons (contraintes fortes de
capacité de traitement, pertes de l'information d'intérêt par les méthodes de
débruitage) tenter d'obtenir l'information de l'image sans réaliser au préalable
un débruitage de l'image.

Approche gradient :
Une première approche consiste à appliquer un détecteur de contours
classique basé sur le calcul du gradient. Le problème rencontré est le suivant :
la variance du gradient sur une zone homogène est d'autant plus que grande
que la puissance de la zone envisagée est élevée. Les queues de la fonction de
densité de probabilité du gradient empiètent alors plus largement sur la
fonction de densité de probabilité du gradient sur une zone de contour. Le
risque de confusion entre un contour et une zone homogène (i.e. La probabilité
de fausse alarme) est plus élevé. Le détecteur de contours basé sur le gradient
est donc inutilisable dans le cas d'une image dont la puissance de ses pixels suit
une loi Gamma, comme c'est le cas avec les images sujettes à un bruit de
speckle.

4/21
Approche ratio :
On s'intéresse alors à un détecteur de contours basé sur le calcul du ratio
de la moyenne de la puissance (ou de l'amplitude) des deux régions contiguës
au pixel d'intérêt (puissances ou amplitudes notées P1 et P2). La fonction de
vraisemblance du ratio R est de la forme :

p R/ P1 , P2=
n  2NL
  NL2 [  P1/ P2NL
n
 R  P1/P2 2NL ] R nNL−1 (2)

où n = 1 (respectivement n = 2) si l'image est une image de puissance

(respectivement d'amplitude) et N le nombre de pixels des régions contiguës au
pixel d'intérêt.
(on considérera dans toute la suite que nous travaillons sur des images de
puissance donc avec n=1)

On constate que, contrairement au gradient, la fonction de densité de

probabilité du ratio, et donc la probabilité de fausse alarme, dans une zone
homogène ne dépendent pas de la puissance moyenne P0 (=P1=P2) puisque
P1/P2=1 dans (2). Les performances du détecteur de contours par calcul du
ratio seront donc discutées en fonctions du nombre de vues L et surtout de la
taille des zones contiguës envisagées (N).

5/21
II. Approche pratique

La base de l’algorithme de Touzi, Lopes et Bousquet est l’équation (2).

Dans un premier temps, nous partons donc de cette équation pour présenter
l’algorithme de manière pratique. Dans un deuxième temps, nous expliciterons
les différentes fonctions matlab que nous avons écrites. Le code de ces
fonctions matlab implémentées se trouve à l’annexe, nous y ferons référence à
chaque nouvelle fonction matlab introduite.

II.1) Algorithme

Partant de l'équation (2), il faut, pratiquement, calculer deux seuils T 1 et

T 2 en fonction d'une probabilité de fausse alarme fixée. Le point considéré est
alors assimilé à :
– un contour si RT 1 ou RT 2
– une zone homogène sinon

Les performances de ce détecteur de contours par ratio est alors fonction

de T1 et T 2 . Afin d'avoir un détecteur symétrique (qui ne dépend pas du sens
dans lequel il opère), il faut alors T 1=T 2 et pour des raisons pratiques il faut
ensuite borner le ratio R :

r =R si R≤1 et r=R−1 si R1 (3)

r ∈[ 0,1] est alors croissant par rapport à la ressemblance entre deux

zones.

Dans ce cas, (2) devient alors :

   
NL NL
P1 P2

P1 n  2NL  P2 P1 nNL−1
pr / = × ×r r ∈[ 0,1] (4)
 
P2   NL 
2
P2
2NL
n
r 
P1

Fixant un seuil T, la probabilité conditionnelle de bonne détection entre

P1 P2
deux zones possédant un contraste de ratio C r =max  ,  est donc :
P2 P1

T
Pd T , C r =P rT /C r =∫0 p r / Cr  dr (5)

6/21
 Et par conséquent, la probabilité de fausse alarme qui correspond à la
probabilité de détecter un contour alors que les zones sont homogènes (i.e.
C r =1 ) s'écrit :

T
Pfa T =Pd T ,1=∫0 p r / Cr=1 dr (6)

On voit d'après cette dernière relation et (4) que Pfa T  dépend du

produit NL (en considérant toujours n=1 ). C’est à partir d’une probabilité de
fausse alarme voulue qu’on peut alors calculer un seuil T .
Le nombre de vues L de l'image SAR traitée est une constante, nous y
reviendrons plus tard.
Par contre, le nombre N correspond à la taille des régions A1 et A2 de
moyennes P1 et P2 . Or pour une meilleure détection de contours, il est
intéressant d’effectuer la détection sur des zones de plus en plus grandes, ce
qui nous amènera à calculer plusieurs seuils.

Détaillons alors en pratique l’algorithme. La détection s’effectue en

chaque pixel de l’image, considérons qu’il s’agit du pixel X .Nous indiçons par
i=1...M les différentes tailles de fenêtres qui serviront à effectuer la détection.
M est alors un paramètre de la détection de contours à définir au même titre
que la probabilité de fausse alarme. Ces fenêtres ont une taille n i×ni où
i
n i =2 1 et sont centrées sur X . Nous commencerons donc à regarder des
ratios de contraste dans deux zones incluses dans la fenêtre 3× 3 , puis 5×5
etc...
Il faut alors définir les deux zones A1 et A2 , afin de pouvoir calculer le
ratio r i . Le choix des zones est important car si par exemple nous coupons la
fenêtre en deux par un segment vertical de pixels (qui ne sera inclus dans
aucune zone) et passant par X , nous aurons alors deux zones pour calculer
r i mais cela mettra alors en évidence les contours verticaux. Il est important
d’imaginer plusieurs directions pour couper la fenêtre : verticale (exemple
précédent), horizontal (le segment qui sépare les deux zones est horizontal et
passe toujours pas X ), et obliques (le segment qui sépare les deux zones
correspond à une des diagonales de la fenêtre, il y a donc deux directions
obliques). Suivant ces 4 découpages de la fenêtre i , on peut alors calculer 4
ratios et nous ne retiendrons que le plus petit correspondant à la plus grande
chance d’avoir un contour.
Remarquons que suivant ces découpages, les zones A1 et A2 auront
ni ×ni −1
chacune Ni= pixels car le segment séparant les deux zones
2
n’appartient à aucune zone. N i correspond au N de l’équation (4), par
conséquent à une probabilité de fausse alarme fixée et avec L et N i , nous
pouvons calculer les différents seuils T i grâce à (6). T i sera considéré
comme un paramètre de la détection de contours car il est constant quelque
soit le pixel où la détection s’effectue. Il est calculer dès le début de
l’algorithme à partir de M et de la probabilité de fausse alarme Pfa qui sont
les paramètres d’entrée de la détection.
L’algorithme est alors assez simple. A chaque pixel, le ratio est calculé

7/21
sur la plus petite taille de fenêtre (i.e. i=1 ). Si 0≤r 1≤T 1 alors on garde r 1
sinon on calcule r 2 . Puis si T 1≤r 2≤T 2 alors on garde r 2 sinon on calcule r 3
et ainsi de suite jusqu’à T M −1≤r M ≤1 . A l’issue de cette première étape, on a
donc conservé un seul ratio r correspondant à une seule taille de fenêtre. La
décision est alors :
– si r ≤T M le point est assimilé à un contour
– sinon à une zone homogène.

Remarques :

– le cheminement de l’algorithme décrit précédemment est applicable en

connaissant L . En connaissant bien l’origine de l’image que l’on veut
traiter, il est possible de connaître par avance L , ce qui n’est pas notre cas
pour les images que nous utiliserons comme test. Quand on ne le connaît
pas, il faut donc le déduire, c’est ce que nous avons essayé de faire de
manière simple. L’idée consiste à considérer L=1 , appliquer la détection
sur une petite partie de l’image et à partir des zones homogènes trouvées,
réévaluer L grâce aux équations sur une zone homogène : E [ X ]=P0 ,
Var [ X ]=PO 2 / L . Ceci devait permettre d’avoir une meilleure estimation
de L plutôt que de fixer L arbitrairement. Or, cette méthode ne nous a pas
donné de résultats satisfaisants et nous n’avons pas eu le temps de nous
pencher plus amplement sur le calcul de L .

– le paramètre M revêt une certaine importance. En effet, plus M est grand,

plus la détection de contours va s’effectuer sur des régions de taille de plus
en plus grande et sera meilleure. Mais par ailleurs, l’épaisseur des contours
trouvés sera lui aussi plus grand. Touzi, Lopes et Bousquet utilisent alors un
traitement d’amincissement de contours basé sur une fermeture
morphologique. Nous n’avons pu mettre en place cette technique car cela
apparaissait assez lourd à implémenter et ne constituait pas la base même
du projet. Cependant, nous avons utilisé une fonction matlab préécrite pour
essayer d’amincir les contours.

II.2) Implémentation et fonctions matlab

L’algorithme a été détaillé à la partie précédente. Nous détaillons

succinctement ici les fonctions matlab écrites et à quelle partie de l’algorithme
elles se réfèrent.

La fonction principale est la fonction ratio_edge_detector.m (p.15 et

16). Elle prend en entrée l’image originale à traiter (sous forme nom de fichier)
et les paramètres M et Pfa . La première étape est le calcul de tous les
paramètres qui serviront à la détection : n i , N i ,lecture de l’image originale,
L , T i (les indices i n’apparaissent pas dans le code puisque nous utilisons

8/21
les vecteurs n , N et T ). Les paramètres dont le calcul a nécessité une
fonction matlab propre sont L et T .
L devrait normalement être évalué par eval_numberLooks.m (p.17)
mais comme expliqué précédemment le résultat n’est pas convenable. Les
résultats à la partie suivante sont donc obtenus avec L=1 arbitrairement.
T est calculé grâce à compute_decision_threshold.m (p.18) qui utilise
(6) pour calculer T en fonction de Pfa , N et L . L’intégrale (6) est calculé
pas à pas afin de se rapprocher de Pfa et d’en déduire la borne T .
Une fois que tous ces paramètres sont calculés, les décisions de contour
sont prises par la fonction edge_detection_core.m (p.18) qui effectuent
simplement des tests sur les ratios par rapport aux seuils T . Les ratios sont
calculés à chaque pixel et pour différentes orientations par
minimum_neighborhood_ratio.m. (p.19 et 20).
A cette étape là, les contours sont détectés mais ont une largeur fonction
de M .La fonction bwmorph de matlab est alors utilisé pour affiner les
contours. Nous montrerons le résultat de cette fonction à la partie suivante
(bwmorph utilisée avec l’option « thin »).

Les deux dernière fonctions matlab importantes sont

create_img_gamma.m (p.20) et gamma_generation.m (p.21) qui permettent
de créer une image avec deux zones de différente texture, qui nous permettra
d’effectuer des tests.

9/21
III. Résultats

Nous présentons ici les résultats obtenus, dans un premier temps avec
une image réelle et puis avec une image de synthèse. A chaque figure est
précisé les paramètres d’entrée ( Pfa et M ) et pour chaque couple de
paramètres d’entrées il y aura deux figures « résultat » : la détection de
contours brute avec des contours trop épais et la détection de contours affinés
grâce à matlab.

III.1) Image réelle

L’image test est « niger_ERS1.tiff »

Fig. 4: niger_ERS1.tiff

– Pfa=0,1 et M =2

Fig. 5: contours bruts Fig. 6: contours amincis

10/21
– Pfa=0,1 et M =5

Fig. 7: contours bruts Fig. 8: contours amincis

– Pfa=0,01 et M =2

Fig. 9: contours bruts Fig. 10: contours amincis

11/21
– Pfa=0,01 et M =5

Fig. 11: contours bruts Fig. 12: contours amincis

Ces différents résultats nous montrent bien l’influence de Pfa et M .

Une probabilité de fausse alarme basse détecte moins de contours et
réciproquement. Quant au rôle de M , il joue clairement sur l’épaisseur des
contours bruts. La fonction d’amincissement de matlab fournit des résultats
médiocres car dans le cas d’une probabilité de fausse alarme élevée, il y a des
faux contours et de plus quand les contours sont épais, certains se rejoignent.
La technique d’amincissement de Touzi, Lopes et Bousquet est certainement
mieux adaptée.
Un bon réglage pour cette image est peut-être Pfa=0,01 et M =3 :

Fig. 13: contours bruts Fig. 14: contours amincis

12/21
III.2) Image de synthèse

L’image test ici est une image comportant deux régions vues comme la
réalisation de deux processus aléatoires décrits par deux densités gamma
différentes. Pour créer une densité gamma d’ordre N, nous avons pris la racine
carré de la somme d’ordre N du carré de variables aléatoires gaussiennes
centrées et réduites.

L’image test pour N1=2 et N2=10 est :

Fig. 15: gamma.tiff

Les histogrammes des deux différentes régions sont alors :

Fig. 16: histogramme de la partie gauche Fig. 17: histogramme de la partie droite

13/21
 Nous obtenons avec les paramètres Pfa=0,05 et M =4 :

Fig. 18: contours bruts Fig. 19: contours amincis

Le résultat est correct mais nous obtenons tout de même des contours
détectés dans la partie gauche et la ligne de séparation des deux zones n’est
pas entièrement détectée. Le paramètre qui pose problème ici est surtout la
probabilité de fausse alarme, si on la baisse on aura moins de faux contours
mais on risque de moins détecter la ligne de séparation, si on l’augmente on
aura encore plus de faux contours dans la partie gauche. Le paramètre M a
moins d’importance, on peut se permettre d’avoir un contour épais vu la
morphologie du contour (ligne vertical), cela pourra se corriger facilement.

III.3) Conclusion

Que ce soit avec une image réelle ou de synthèse nous obtenons donc des
résultats corrects sans être exceptionnels, ce qui nous paraît légitime car pour
implémenter nous avons fait des hypothèses (sur L et sur le fait que les
images soient des images de puissance) et nous avons utilisé un outil de matlab
pour affiner les contours qui n’aient pas parfaitement adapté à cette détection.
Cependant, même si il est possible d’aller plus loin, ce projet nous a
donné une bonne vision de la détection de contours par ratio proposé par Touzi,
Lopes et Bousquet.

14/21
ANNEXE
Le code des fonctions matlab implémentées sont regroupées ici à titre
consultatif.

- ratio_edge_detector.m

% This routine returns a SAR image with detected edges

% using a ratio edge detector
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%
% Inputs :
% 1. img = filename (string) of the original image
% 2. Pfa = false alarm probability
% 3. M = number of different neighborhood sizes
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%
% Outputs :
% 1. img_edge = final image with detected edges
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%

function [img_edge] = ratio_edge_detector(img,Pfa,M)

% Parameters

disp('');
disp('- Window sizes ni');
n = 2.*[1:1:M]+1 % window sizes (n x n)

disp('');
disp('- Numbers of pixels in different neighborhoods Ni');
N = n.*(n-1)/2 % numbers of pixels in different neighborhoods

I = (imread(img)); % original image

l=size(I,1); % number of lines
c=size(I,2); % number of columns
dl = (n(M)+1)/2;
dc = (n(M)+1)/2;

disp('');
disp('- L evaluation');
L=1
%L = eval_numberLooks (I,dl,dc,l,c,M,n,N,Pfa); % evaluate number of looks L (L-look SAR
image)

T = zeros(1,M+2); % thresholds array

for i=1:M-1
T(i+1) = compute_decision_threshold(Pfa,N(i),L); % compute decision threshold T
end
T(M+1) = 1;
T(M+2) = compute_decision_threshold(Pfa,N(M),L);
disp('');
disp('- With evaluated L different thresholds Ti');

15/21
T,

% Edge detection

disp('');
disp('- Edge detection');
img_edge = edge_detection_core(I,dl,dc,l,c,M,n,T);
img_edge_inverse = -img_edge+255;

% thinning

img_edge_thin = -bwmorph(img_edge_inverse,'thin',Inf)+1;

% skeletonizing

img_edge_skel = -bwmorph(img_edge_inverse,'skel',Inf)+1;

% Sobel edge detection

bw = edge(I,'sobel','both');

% Displays

figure(1)
imshow(I);

figure(2)
imshow(img_edge);

figure(3)
imshow(img_edge_thin);

figure(4)
imshow(img_edge_skel);

figure(5)
imshow(bw);

end

16/21
- eval_numberLooks.m

% Evaluates the number of looks of the image from Z homogenous regions

function L = eval_numberLooks (I,dl,dc,l,c,M,n,N,Pfa)

Z = 500;
L_temp = zeros(1,Z);
iter_L = 0;

% consider L=1 in order to compute threshold arrays

T_temp = zeros(1,M+2);
for i=1:M-1
T_temp(i+1) = compute_decision_threshold(Pfa,N(i),1); % compute decision threshold T
end
T_temp(M+1) = 1;
T_temp(M+2) = compute_decision_threshold(Pfa,N(M),1);
disp('----> with L=1 different thresholds Ti = ');
T_temp,

% Edge detection processing

for i = dl:l-dl
for j = dc:c-dc

iter = 1;
while (iter <= M)
[r,P0,V] = minimum_neighborhoods_ratio(I,i,j,n(iter)) ;
if ( r >= T_temp(iter) & r <= T_temp(iter+1) )
iter = M+1;
else
iter = iter+1;
end
end

if ( r > T_temp(M+2) ) % homogeneous area

iter_L = iter_L + 1;
L_temp(iter_L) = P0 / V; % grab number looks
end

if iter_L == Z, break, end

end

if iter_L == Z, break, end

end

disp ('----> L evaluation');

L = mean (L_temp)

end

17/21
- compute_decision_threshold.m
% Computes decision threshold using Pfa, N and L

function T = compute_decision_threshold (Pfa,N,L)

NL = N*L;
P=0;
H = 0.001 ;
S=0;

while (P <= Pfa)

P = P + H * gamma(2*NL)/(gamma(NL))^2 * (2 / (S+1)^(2*NL))*S^(NL-1) ;
S=S+H;
end

T = S;

- edge_detection_core
% Proceeds the edge detection decisions

function img_edge = edge_detection_core (I,dl,dc,l,c,M,n,T)

img_edge = zeros(l,c); % final image with detected edges

% Edge detection processing

lim_time = 0.1;
for i = dl:l-dl
for j = dc:c-dc

time=i*j/l/c;
if (time >= lim_time)
[s,err] = sprintf('%d%s',round(lim_time*100),'%');
disp(s);
lim_time = lim_time+0.1;
end

iter = 1;
while (iter <= M)
[r,P0,V] = minimum_neighborhoods_ratio(I,i,j,n(iter)) ;
if ( r >= T(iter) & r <= T(iter+1) )
iter = M+1;
else
iter = iter+1;
end
end

if ( r > T(M+2) )
img_edge(i,j) = 255;
end

end
end

end

18/21
- minimum_neighborhoods_ratio.m
% Computes the minimum neighborhood ratio using the usual directions

function [r,P0,V] = minimum_neighborhoods_ratio(I,i,j,nw)

d = (nw-1)/2;

% Vertical direction
N1 = I(i-d:i+d,j+1:j+d); % neighborhood 1
N2 = I(i-d:i+d,j-d:j-1); % neighborhood 2
P1 = mean(mean(N1)); % mean power 1
P2 = mean(mean(N2)); % mean power 2
rv = P1/P2; % ratio of mean powers
if ( rv > 1)
rv = 1/rv;
end

% Horizontal direction (evaluate by the way variance and mean over the region)
N1 = I(i+1:i+d,j-d:j+d);
N2 = I(i-d:i-1,j-d:j+d);
P1 = mean(mean(N1));
P2 = mean(mean(N2));
rh = P1/P2;
if ( rh > 1)
rh = 1/rh;
end

N = [N1 N2];
u = size(N,1)*size(N,2);
N = reshape (N,1,u);
P0 = mean ([P1 P2]);
V = var(double(N));

% Oblic direction /
P1 = 0;
P2 = 0;
for il=1:nw-1
P1 = P1 + sum(I(i-d+il-1,j-d:j+d-il));
P2 = P2 + sum(I(i+d-il+1,j-d+il:j+d));
end
ro1 = P1/P2;
if ( ro1 > 1)
ro1 = 1/ro1;
end

% Oblic direction \
P1 = 0;
P2 = 0;
for il=1:nw-1
P1 = P1 + sum(I(i+d-il+1,j-d:j+d-il));
P2 = P2 + sum(I(i-d+il-1,j-d+il:j+d));
end
ro2 = P1/P2;

19/21
if ( ro2 > 1)
ro2 = 1/ro2;
end
% if (P2 == 0)
% I(i-d:i+d,j-d:j+d),
% ro2,
% end

% Minimum ratio
r = min([rv,rh,ro1,ro2]);

end

- create_img_gamma.m
% creates a L*C image (L lines, C columns)
% with two homogeneous areas (N1-order and N2-order gamma distribution)
% the separation is the vertical middle line

function img_gamma = create_img_gamma (L,C, N1, N2)

T = L*C ; % image size

A1 = gamma_generation(L, round(C/2), N1) ; % homogeneous area 1
A2 = gamma_generation(L, C-round(C/2), N2) ; % homogeneous area 1
A1 = A1*255/max(max(A1)) ;
A2 = A2*255/max(max(A2)) ;

% display histograms of the homogeneous areas

X1 = [floor(min(min(A1))):1:ceil(max(max(A1)))] ;
X2 = [floor(min(min(A2))):1:ceil(max(max(A2)))] ;
Nh1 = hist(reshape(A1,L*round(C/2),1), X1) ;
Nh2 = hist(reshape(A2,L*(C-round(C/2)),1), X2) ;
figure(1)
stem(X1, Nh1)
xlabel('Gray levels')
ylabel('Number of pixels')
figure(2)
stem(X2, Nh2)
xlabel('Gray levels')
ylabel('Number of pixels')

% create image
img_gamma = zeros(L,C) ;
img_gamma(:,1:round(C/2)) = A1 ;
img_gamma(:,round(C/2)+1:C) = A2 ;
img_gamma = uint8(img_gamma) ;
min(min(img_gamma))
max(max(img_gamma))
figure(3)
imshow(img_gamma) ; % display image
imwrite (img_gamma, 'gamma.tiff', 'tiff') ; % save image as TIFF format

20/21
- gamma_generation.m
% generates L*C N-order gamma random variables

function Ga = gamma_generation(L,C,N)

Gu = randn(N,L,C) ; % N*L*C guassian random variables (mean=0, variance=1)

Gu = Gu.*Gu ;
Gu = sum(Gu) ;
Ga = reshape(Gu.^(0.5),L,C) ; % --> L*C N-order gamma random variables

21/21