Discussion :

[DaTheWolf]

Le titre semble idiot ou non ?

Je calcule nabla f(x, y) f l'image à une composante intensité ou rgb une à une.

À partir de là je voudrais l'intégrer avec des carrés jaunes fléchés- orientés à base de treillage de forme rectangulaire éventuellement superposés en minimisant la différence d'énergie avec l'original et en rendant les rectangles les plus significant possibles.

Juste des polylignes épaisses je retrouve pas le document.

J'ai déjà essayé plusieurs solutions sans succès.

[wiwaxia]

... Je calcule nabla f(x, y) f l'image à une composante intensité ou rgb une à une ...

... À partir de là je voudrais l'intégrer avec des carrés jaunes fléchés- orientés à base de treillage de forme rectangulaire éventuellement superposés en minimisant la différence d'énergie avec l'original et en rendant les rectangles les plus significant possibles.

Juste des polylignes épaisses je retrouve pas le document ...

Là, c'est incompréhensible. Peux-tu donner quelques explications, ou citer les sources concernant ce type de calcul ?

[DaTheWolf]

J'ai supprimé le lien.
En fait je cherche à faire de la reconnaissance de formes et d'objets.
Je suis un cours en ligne mais je bloque sur le premier exercice.

[wiwaxia]

J'ai supprimé le lien ...

Bon, OK.

... En fait je cherche à faire de la reconnaissance de formes et d'objets.
Je suis un cours en ligne mais je bloque sur le premier exercice.

Peux-tu passer en capture d'écran (à défaut du lien d'accès) l'énoncé de l'exercice, et le passage essentiel du cours en rapport avec la question ?

[DaTheWolf]

https://courses.cs.washington.edu/co...1/project1.htm
Le point qui bloque c est les points d interet et les features. j etais parti sur une methode de harris et puis j ai essaye autre chose comme reconnaitre des courbes d epaisseur a determiner dans les images.

[wiwaxia]

Voici quelques éléments de réponse, tirés du document cité, et dont le contenu apparaît relativement clair (au moins au début).

Le second lien ci-dessous conduit à une confirmation de ce qui précède:

J'ai trouvé beaucoup de liens dont j'ignore si tu les connais déjà:

https://fr.wikipedia.org/wiki/D%C3%A...%C3%A9r%C3%AAt
https://ensiwiki.ensimag.fr/images/d...ris_corner.pdf
https://core.ac.uk/download/pdf/15494344.pdf
https://www.researchgate.net/figure/...fig4_233795134

[DaTheWolf]

Le lien que tu me donne sur le détecteur subpixellique par passage à zéro me semble correspondant à ce que je cherche pour trouver des lignes, moustaches sourcils, plis de masque et draps même un ciel nuageux peut-être.
Je dois dire que l'explication de la variation de la matrice de harris par theto, l'ambassadeur de cos sine je ne comprends pas.

[wiwaxia]

Le lien que tu me donne sur le détecteur subpixellique par passage à zéro me semble correspondant à ce que je cherche ....

Il vaudrait peut-être mieux te familiariser avec le procédé de base, avant de passer à des variantes plus compliquées.

... Je dois dire que l'explication de la variation de la matrice de harris par theto, l'ambassadeur de cos sine je ne comprends pas.

Moi non plus, d'ailleurs.

Tu te réfères sans doute au bref passage où figurent les fonctions trigonométriques (Sin(θ), Cos(θ)), dépendant du paramètre "theta" (θ) - on emploie souvent le caractère grec correspondant à la consonne "th".

La détection d'un coin repose essentiellement sur le fait que bien que le déterminant de chaque matrice M_p soit nul, celui de la matrice moyenne (H) ne l'est pas.

Le déterminant de la matrice moyenne Det(H) = Det(∑_pw_p*M_p)
diffère généralement de la moyenne des déterminants des matrices individuelles ∑_pw_p*Det(M_p) ,
lesquels (comme cela vient d'être dit) sont par définition tous nuls:

Det(M_p) = (D_xI²)*(D_yI²) – (D_xI*D_yI)² = 0 .

[DaTheWolf]

Quand j'ai calculé Mp 2x2 pour chaque point, que processus pour déterminer les poids wp ?
Il faut que je relise le document.

Concrètement ici:

Comment extraire l'information ? Contours des yeux, nez bouche alors que le résultat est très bruité ?

[wiwaxia]

... quel processus pour déterminer les poids wp ? ...

En principe une fonction gaussienne de la forme A*Exp(-Bd²) = A*Exp(-B(x² + y²⁾)) .

Il pourra être avantageux de pré-calculer les valeurs peu nombreuses de ce coefficient; par exemple pour un domaine carré de côté 3 , il n'interviendra que 3 résultats différents mémorisables dans un tableau:
# (x, y) = (0, 0): w = A (au centre du domaine);
# (x, y) = (0, 1) ou (1, 0): w = A*Exp(-B) ;
# (x, y) = (1, 1); w = w = A*Exp(-2B) (en l'un de ses 4 coins).

Et pour l'allègement des calculs et des données, rien n'interdit de se ramener à des valeurs entières en prenant par exemple
A = 100 et B = 1.0 (ce dernier terme reste un nombre décimal):
# (x, y) = (0, 0): w = 100;
# (x, y) = (0, 1) ou (1, 0): w = 100*Exp(-1) = 37 ;
# (x, y) = (1, 1); w = w = 100*Exp(-2) = 14 .
Il serait bon que d'autres donnent leur avis là-dessus.

[wiwaxia]

Je découvre l'image à l'instant.
Une coloration binaire entraîne une dégradation de l'information.
Il faut stocker momentanément les matrices (Mp) dans un tableau bidimensionnel.

PS: les matrices Mp étant symétriques (m₁₂ = m₂₁), leur définition se ramène au triplet

(m₁₁, m₁₂, m₂₂) .

À la réflexion, je ne comprend pas la correspondance entre les matrices (2×2), constituées de 4 termes, et les pixels.

[wiwaxia]

J'ai regardé ce que cela donnait sur une image simple, celle résultant de la partition du plan en cellules de couleurs aléatoires.
Les valeurs obtenues (r) se répartissent sur un domaine contenant zéro, entre deux bornes (Rmin, Rmax) de signes opposés:

Les points sont très inégalement répartis suivant le signe du résultat; on a retenu ici ceux vérifiant:
# r > Fr * Rmax (points jaunes - ou rouges sur la dernière image);
# r < Fr * Rmin (points cyan - ou bleus sur la dernière image); avec en plus Fr = 0.500 .

[DaTheWolf]

interessant. pour ma part, entretemps,
j ai fait quelque chose de different,
j ai applique la methode a une image, en coloriant
par apres les points nuls avec des couleurs avoisinantes.

[wiwaxia]

Le résultat est intéressant, surtout au niveau de la dernière image.

J'avoue ne pas comprendre l'apparition des polygones.

[wiwaxia]

On augmente le nombre de points en choisissant un coefficient plus faible.

Ici, à partir du même original, en prenant Fr = 0.050: r > Fr * Rmax (points rouges) / r < Fr * Rmin (points bleus)

Le nombre de points obtenus est plus élevé dans le cas de l'image d'un objet réel
- ici Fr = 0.500 , (r > Fr * Rmax) ou (r < Fr * Rmin) (points mauves)

Le résultat paraît décevant, les points présentant une répartition aléatoire sans lien visible avec les singularités de l'image initiale.
Peut-être faudrait-il
- recourir à une définition plus appropriée de l'intensité (I) du pixel ? On peut envisager une expression moins élémentaire que la somme I = r + v + b ;
- procéder à un lissage préalable de l'image initiale, comme il me semble l'avoir vu mentionné ?
- effectuer les calculs sur des domaines plus étendus, (5x5) pixels au lieu de (3x3) ?

[wiwaxia]

En redéfinissant l'intensité par la somme des carrés des composantes couleur:

I = r² + v² + b²

on obtient une meilleure distribution des points, qui paraissent de rassembler sur les lignes de plus fort contraste de luminance.

[DaTheWolf]

on utilise sans doute pas le meme algorithme.
ici en seuillant certaines couleurs on obtient des resultats plus precis? c'est bien ca?

ps la blonde est magnifique.

[wiwaxia]

... ps la blonde est magnifique.

Brigitte Bardot, pour les intimes.

[wiwaxia]

L'essentiel du programme réside dans le passage de la matrice du corps de la première image (Matrice_1) à celle de la seconde (Matrice_2); il s'agit de tableaux bidimensionnels de pixels déclarés comme suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 CONST Dim_Max = 1500;
 
 TYPE Pixel = ARRAY[1..3] OF Byte;
      Tab_Pix = ARRAY[0..Dim_Max, 0..Dim_Max] OF Pixel;
 
 VAR Larg_Image, Haut_Image, T_Fichier, T_Image: Z_32;          // Z_32 = LongInt    
     Matrice_1, Matrice_2: Tab_Pix;

il est réalisé par la procédure Calc_Mat_Im2(Larg_Image, Haut_Image, Matrice_1, Matrice_2);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 PROCEDURE Calc_Mat_Im2(La, Ha: Z_32; VAR Ma1, Ma2: Tab_Pix);
   CONST m = 255; Fr = 0.001;
         P000: Pixel = (0, 0, 0);
         P100: Pixel = (m, 0, 0);
         P001: Pixel = (0, 0, m);
         P101: Pixel = (m, 0, m);
         P110: Pixel = (m, m, 0);
   VAR Xm, Ym: Z_32; Det, p, q, r, Rm1, Rm2, Rmax, Rmin: Reel;
       Th: Tab_3E; Px: Pixel;
   BEGIN
     Calc_MatTr(Larg_Image, Haut_Image, MatTr);
     Calc_RminRmax(Larg_Image, Haut_Image, Rmin, Rmax);
     Aff_F_Rminmax(Fr, Rmin, Rmax);
     Rm1:= Fr * Rmax;       Rm2:= Fr * Rmin;
     ZeroM(Matrice_2);
     FOR Xm:= 0 TO (La - 1) DO
       FOR Ym:= 0 TO (Ha - 1) DO
         BEGIN
           Th:= F_TabH(La, Ha, Xm, Ym);
           p:= Th[0] * Th[2]; q:= Sqr(Th[1]);
           Det:= p - q;       q:= Th[0] + Th[2];
           IF (q=0) THEN r:= 0 ELSE r:= Det / q;
           IF (r>Rm1) THEN Px:= P101
                      ELSE IF (r<Rm2) THEN Px:= P101
                                      ELSE Px:=Ma1[Xm, Ym];
           Ma2[Xm, Ym]:= Px
         END
   END;

L'excès de pixels prédéfinis en constantes est lié au nombre des options envisagées.

On a vu que les matrices locales (M_P), matrices carrées d'ordre 2 définies par le produit Grad(P).Grand(P)^T ,
sont réductibles du fait de leur symétrie (m₁₂ = m₂₁) au triplet de réels (m₁₁ = D_x² , m₁₂ = D_x*D_y , m₂₂ = D_y²) .

En première étape, intervient le calcul de la matrice de triplets:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 TYPE Tab_3R = ARRAY[0..2] OF Reel;
      Tab_TrE = ARRAY[0..Dim_Max, 0..Dim_Max] OF Tab_3R;
 
 TYPE Tab_3R = ARRAY[0..2] OF Reel;
      Tab_TrR = ARRAY[0..Dim_Max, 0..Dim_Max] OF Tab_3R;
 
 VAR Lst3R: Tab_3R;
     MatTr: Tab_TrR;
 
                    // Calcul de la matrice de triplets
 PROCEDURE Calc_MatTr(La, Ha: Z_32; VAR M_Tr: Tab_TrR);
   VAR Xm, Ym: Z_32;
   BEGIN
     FOR Xm:= 0 TO (La - 1) DO
       FOR Ym:= 0 TO (Ha - 1) DO
         M_Tr[Xm, Ym]:= F_MatP(Xm, Ym)
   END;
 
 Calc_MatTr(Larg_Image, Haut_Image, MatTr);

dont chacun des termes est obtenu par la fonction F_MatP(Xm, Ym):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
                    // Calcul de la matrice (2x2) locale ramenée à un triplet
 FUNCTION F_MatP(x, y: Z_32): Tab_3R;
   VAR DxI, DyI, Q2sDx, Q2sDy, X1, X2, Y1, Y2, z: Z_32; Ta: Tab_3R;
     BEGIN
       Calc_XiYi(Larg_Image, Haut_Image, x, y, X1, X2, Y1, Y2);
       Q2sDx:= 2 DIV (X2 - X1);      Q2sDy:= 2 DIV (Y2 - Y1);
       z:= Int_Px(Matrice_1[X2, y]); Dec(z, Int_Px(Matrice_1[X1, y]));
       DxI:= z * Q2sDx;
       z:= Int_Px(Matrice_1[x, Y2]); Dec(z, Int_Px(Matrice_1[x, Y1]));
       DyI:= z * Q2sDy;
       Ta[0]:= Sqr(DxI);             Ta[2]:= Sqr(DyI);
       Ta[1]:= DxI * DyI;            Result:= Ta
     END;

Celle-ci calcule les valeurs entières doubles des composantes (Dx, Dy), afin d'éviter d'éventuelles résultats semi-entiers dans le cas de points à la limite de l'image (x ou y nuls ou égaux à (Largeur - 1) ou (Hauteur - 1)). Il faut peut-être revenir là-dessus.

Le détail le plus contestable de l'algorithme est la réduction du calcul à une seule paire de données:

Dx = (I[x+1, y] - I[x-1, y]) , Dy = (I[x, y+1] - I[x, y-1]) ;

on pourrait faire intervenir, sur le même domaine (3x3), 3 paires de valeurs.

L'algorithme repère les frontières séparant les zones de luminosité contrastée, mais pas spécialement les angles.

[wiwaxia]

Le programme source complet relatif au calcul de la seconde matrice de pixels (Matrice2):

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 CONST K_Entete = 54; Dim_Max = 1500;
       Chemin = 'D:\ZZZZZZ\#\';
 
 TYPE Pixel = ARRAY[1..3] OF Byte;
      Tab_Pix = ARRAY[0..Dim_Max, 0..Dim_Max] OF Pixel;
 
 VAR Larg_Image, Haut_Image, T_Fichier, T_Image: Z_32;     // Z_32 = LongInt
     ... / ...
     Matrice_1, Matrice_2: Tab_Pix;
 
... / ...
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Calcul de la seconde matrice
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
                              // Calcul des valeurs extrêmes des coordonn‚es
 PROCEDURE Calc_XiYi(La, Ha, Xp, Yp: Z_32;
                     VAR Xmin, Xmax, Ymin, Ymax: Z_32);
   VAR X1, X2, Y1, Y2: Z_32;
   BEGIN
     X1:= Xp - 1; IF (X1<0)   THEN X1:= 0;      Xmin:= X1;
     X2:= Xp + 1; IF (X2>=La) THEN X2:= La - 1; Xmax:= X2;
     Y1:= Yp - 1; IF (Y1<0)   THEN Y1:= 0;      Ymin:= Y1;
     Y2:= Yp + 1; IF (Y2>=Ha) THEN Y2:= Ha - 1; Ymax:= Y2
   END;
 
 TYPE Tab_3R = ARRAY[0..2] OF Reel;
      Tab_TrR = ARRAY[0..Dim_Max, 0..Dim_Max] OF Tab_3R;
 
 VAR Lst3R: Tab_3R;
     MatTr: Tab_TrR;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Calcul de la matrice de triplets
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 CONST C0 = 100; C1 = 37; C2 = 14;
       C: ARRAY[0..2] OF Byte = (C0, C1, C2);
       Sc1 = 4 * (C1 + C2); ScMax = C0 + Sc1;
 
                    // Calcul des triplets représentant la matrice de Harris
 FUNCTION F_TabH(La, Ha, x, y: Z_32): Tab_3R;
   CONST Tzero: Tab_3R = (0, 0, 0);
   VAR i: Byte; D2, Ix, Iy, s, Sc, Sh, Sx, Sy, X1, X2, Y1, Y2: Z_32;
       q: Reel; Th, Tx: Tab_3R;
   BEGIN
     Calc_XiYi(Larg_Image, Haut_Image, x, y, X1, X2, Y1, Y2);
     Sc:= 0;         Tx:= Tzero;
     FOR Ix:= X1 TO X2 DO
       BEGIN
         Sx:= Abs(Ix - x);
         FOR Iy:= Y1 TO Y2 DO
           BEGIN
             Sy:= Abs(Iy - y); s:= Sx + Sy; Inc(Sc, C[s]);
             FOR i:= 0 TO 2 DO IncR(Tx[i], C[s] * MatTr[Ix, Iy][i])
           END
       END;
     q:= ScMax / Sc; FOR i:= 0 TO 2 DO Th[i]:= q * Tx[i];
     Result:= Th
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Calcul des triplets d'entiers
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 FUNCTION Int_Px(Px: Pixel): Z_32;                // Intensit‚ du pixel
   VAR s: Z_32;
   BEGIN
     s:= Sqr(Px[1]); Inc(s, Sqr(Px[2])); Inc(s,Sqr(Px[3]));
     Result:= s
   END;
 
                    // Calcul de la matrice (2x2) locale ramenée … un triplet
 FUNCTION F_MatP(x, y: Z_32): Tab_3R;
   VAR DxI, DyI, Q2sDx, Q2sDy, X1, X2, Y1, Y2, z: Z_32; Ta: Tab_3R;
     BEGIN
       Calc_XiYi(Larg_Image, Haut_Image, x, y, X1, X2, Y1, Y2);
       Q2sDx:= 2 DIV (X2 - X1);      Q2sDy:= 2 DIV (Y2 - Y1);
       z:= Int_Px(Matrice_1[X2, y]); Dec(z, Int_Px(Matrice_1[X1, y]));
       DxI:= z * Q2sDx;
       z:= Int_Px(Matrice_1[x, Y2]); Dec(z, Int_Px(Matrice_1[x, Y1]));
       DyI:= z * Q2sDy;
       Ta[0]:= Sqr(DxI);             Ta[2]:= Sqr(DyI);
       Ta[1]:= DxI * DyI;            Result:= Ta
     END;
 
                    // Calcul de la matrice de triplets
 PROCEDURE Calc_MatTr(La, Ha: Z_32; VAR M_Tr: Tab_TrR);
   VAR Xm, Ym: Z_32;
   BEGIN
     FOR Xm:= 0 TO (La - 1) DO
       FOR Ym:= 0 TO (Ha - 1) DO
         M_Tr[Xm, Ym]:= F_MatP(Xm, Ym)
   END;
 
                              // Valeurs extrêmes de la grandeur locale (r)
 PROCEDURE Calc_RminRmax(La, Ha: Z_32; VAR R_min, R_max: Reel);
   VAR Xm, Ym: Z_32; Det, p, q, r, Rmax, Rmin: Reel; Th: Tab_3R;
   BEGIN
     Rmax:= 0; Rmin:= 0;
     FOR Xm:= 0 TO (La - 1) DO
       FOR Ym:= 0 TO (Ha - 1) DO
         BEGIN
           Th:= F_TabH(La, Ha, Xm, Ym);
           p:= Th[0] * Th[2]; q:= Sqr(Th[1]);
           Det:= p - q;       q:= Th[0] + Th[2];
           IF (q=0) THEN r:= 0 ELSE r:= Det / q;
           IF (Rmax<r) THEN Rmax:= r;
           IF (Rmin>r) THEN Rmin:= r;
         END;
     R_min:= Rmin; R_max:= Rmax
   END;
                                        // Affichage des valeurs extrêmes
 PROCEDURE Aff_F_Rminmax(F_, Min, Max: Reel);
   CONST v = 11;
   BEGIN
     E(0015); Wt(4, 40, 'Fr = ');  E(0012); Write(F_:6:4);
     E(0015); Write('   Rmin = '); E(0010); Write(Min:v);
     E(0015); Write('   Rmax = '); E(0010); Write(Max:v)
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE ZeroM(VAR Ma: Tab_Pix);                          // Mise … z‚ro
   CONST Pzero: Pixel = (0, 0, 255);
   VAR i, j: Z_32;
   BEGIN
     FOR i:= 0 TO Dim_Max DO
       FOR j:= 0 TO Dim_Max DO Ma[i, j]:= Pzero
   END;
 
                    // Calcul de la matrice du corps de la seconde image
 
 PROCEDURE Calc_Mat_Im2(La, Ha: Z_32; VAR Ma1, Ma2: Tab_Pix);
   CONST m = 255; Fr = 0.001;
         P000: Pixel = (0, 0, 0);
         P100: Pixel = (m, 0, 0);
         P001: Pixel = (0, 0, m);
         P101: Pixel = (m, 0, m);
         P110: Pixel = (m, m, 0);
 
   VAR Xm, Ym: Z_32; Det, p, q, r, Rm1, Rm2, Rmax, Rmin: Reel;
       Th: Tab_3R; Px: Pixel;
   BEGIN
     Calc_MatTr(Larg_Image, Haut_Image, MatTr);
     Calc_RminRmax(Larg_Image, Haut_Image, Rmin, Rmax);
     Aff_F_Rminmax(Fr, Rmin, Rmax);
     Rm1:= Fr * Rmax;       Rm2:= Fr * Rmin;
     ZeroM(Matrice_2);
     FOR Xm:= 0 TO (La - 1) DO
       FOR Ym:= 0 TO (Ha - 1) DO
         BEGIN
           Th:= F_TabH(La, Ha, Xm, Ym);
           p:= Th[0] * Th[2]; q:= Sqr(Th[1]);
           Det:= p - q;       q:= Th[0] + Th[2];
           IF (q=0) THEN r:= 0 ELSE r:= Det / q;
           IF (r>Rm1) THEN Px:= P101
                      ELSE IF (r<Rm2) THEN Px:= P101
                                      ELSE Px:=Ma1[Xm, Ym];
           Ma2[Xm, Ym]:= Px
         END
   END;

PS: Les composantes (Dx, Dy) du vecteur Grad(I) sont nulles dans toute zone de coloration uniforme; il en va alors de même pour les 4 éléments de la matrice de Harris, dont la grandeur caractéristique n'est plus définie; il faut donc dans ce cas assigner à cette dernière une valeur arbitraire pour éviter un plantage à l'exécution - en pratique, zéro.
Le bloc d'instructions ci-dessous intervient deux fois:

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
           p:= Th[0] * Th[2]; q:= Sqr(Th[1]);
           Det:= p - q;       q:= Th[0] + Th[2];
           IF (q=0) THEN r:= 0 ELSE r:= Det / q; 

Le programme, assez lourd, comporte sûrement de nombreux détails à rectifier.