Discussion :

[wiwaxia]

# Suite du #291, où ont été données les palettes et les codes correspondants.

Le problème paraît au départ plus encombrant, parce que chaque composante couleur suit une loi de variation qui lui est propre.
Mais une fois cette difficulté passée, l'initialisation de la matrice du corps de l'image s'en trouve grandement facilitée, qu'il s'agisse de la palette unidimensionnelle ou du cercle chromatique.

Voici les graphes de variation des trois composantes sur le domaine [0 ; 6] correspondant à une période, le paramètre ajustable (h) prenant successivement les valeurs (0, 0.5 et 1.0):

h = 0.000
h = 0.500
h = 1.000

On observe pour les trois composantes, une évolution progressive
# depuis une fonction linéaire par morceaux (h = 0 , branches rectilignes se raccordant à leurs voisines en leurs extrémités),
# jusqu'au cas limite des arcs de paraboles dont les tangentes viennent se confondre en leur sommet avec les paliers horizontaux d'ordonnée maximale.

Les discontinuités de pente, qui sont au départ les plus brutales (h = 0), se traduisent par des raies anormalement brillantes dans la palette, dans le vert et le jaune essentiellement:

h = 0.000 h = 0.500 h = 1.000

Au-delà, elles s'estompent progressivement pour disparaître, d'une manière concomitante à l'atténuation des ruptures de pentes au voisinage des paliers horizontaux, qui s'annulent routes pour (h = 1).

# Les intensités des couleurs étant limitées à 255, le paramètre (h) ne doit théoriquement pas dépasser l'unité; néanmoins, en raison de l'intervention de l'arrondi final

Code :

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

Px[i]:= Round(255 * w)

les anomalies de dépassement n'apparaissent qu'au-delà de 1.092:

_

Il serait donc possible de "doper" la fonction couleur en montant la valeur de (h) à 1.092 - voir la palette ci-dessus - bien que celle-ci ne présente pas d'intérêt particulier.

# La constitution de cette palette (RJB), bien que logique, présente cependant un détail arbitraire: au bleu pur (0, 0, 255) est opposé l'orange (255, j, 0) dont la teinte dépend de (h) et peut de pas convenir: on peut effectivement déplorer la trop grande extension du jaune dans l'ensemble.

Code :

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

1
2
3
t = 1 pour l'orange opposé au bleu
h =    0.0   0.2   0.4   0.6   0.8   1.0
j =    128   140   153   166   179   191

Il n'est pas exclu d'envisager une légère dévaluation de la composante jaune.

[Jipété]

Exposé très intéressant.

En regardant attentivement avec un grand écran les trois graphes superposés, une évidence se fait jour : s'il y a trop de jaune à (h = 1.0) c'est parce qu'il y a trop de vert, à cause de la parabole. Et pareil pour le mauve.
Il faudrait tester avec une montée en forme de S allongé, une sigmoïde (même pas je savais que ça s'appelait comme ça ! Merci ggl).

Ça serait facile à remplacer ? Pour toi surement, pour moi même pas j'y pense (quoique, avec une fonction tangente hyperbolique…)

Maintenant, à voir s'il faut l'appliquer aux 3 couleurs primaires.
Il faudrait qu'on puisse choisir.

EDIT :
J'ai bricolé ça à la va-vite, ça rend assez bien SAUF pour le dégradé horizontal qui morfle, suite à la compression gif qui n'est pas capable par construction de rendre toutes les couleurs, on en a déjà parlé.


Ah, j'ai hâte de voir la même chose avec des sigmoïdes !

EDIT2 :
Ah pi y a ça aussi, et impossible de faire mieux, le gif détruit complètement les dégradés des cercles :

[wiwaxia]

... En regardant attentivement avec un grand écran les trois graphes superposés, une évidence se fait jour : s'il y a trop de jaune à (h = 1.0) c'est parce qu'il y a trop de vert, à cause de la parabole. Et pareil pour le mauve.
Il faudrait tester avec une montée en forme de S allongé, une sigmoïde (même pas je savais que ça s'appelait comme ça ! Merci ggl) ...

1°) Le premier graphe reste à la base de la constitution des palettes (RJB) du fait de l'opposition des couleurs complémentaires, régulièrement espacées: R-V, Or-B, J-V. On doit toutefois arrondir les angles, mais il y a plusieurs solutions.

2°) Je comprends ton idée de marche arrondie; cependant les sigmoÏdes et apparentées ne conviennent pas, car elles sont définies sur ]-Inf ; +Inf[ .
Un petit polynôme approprié pourra très bien convenir; je regarde cela dès que possible.

[wiwaxia]

Il n'a pas été nécessaire de chercher loin pour trouver quelques fonctions simples apportant les modifications souhaitées, et dont l'ajustement est à la portée d'un élève de première.
Trois cas particuliers ont été testés ici, appartenant à la même famille générique; d'autres exemples ne sont nullement exclus.

Le code concernant le calcul des couleurs locales a été remanié (il ne pouvait d'ailleurs subsister en l'état), mais l'accroissement de complexité est resté limité:

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
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
 CONST m = 255; Kh = 1.000; Version = 3;
 
 FUNCTION Norme1(u, v: Reel): Reel;
   VAR U2, V2: Reel;
   BEGIN
     U2:= Sqr(u); V2:= Sqr(v); Result:= Sqrt(U2 + V2)
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Seconde version - 3 options
 
 Q1 = 0.5*(sý/4)*(3 - sý/4)             Q2 = 0.5*(sý/4)ý*(5 - 3*xý/4)
 
 Q3 = 0.25*(s/2)^4*(7 - 3*(s/2)^4)
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 FUNCTION Q(h, i, j, s: Reel): Reel;
   VAR p, q, r: Reel;
   BEGIN
     p:= s - i; q:= j - s;
     r:= p * q; Result:= h * r
   END;
 
 FUNCTION Px3(t: Reel): Byte;                    // t varie de 0 … 6
   VAR w: Reel; Test1, Test2: Bool;
   BEGIN
     Test1:= ((4<t) AND (t<5));
     Test2:= (t<3);
     IF Test1 THEN w:= 1
              ELSE IF Test2 THEN w:= 0
                            ELSE IF (t<4.5) THEN BEGIN
                                                   w:= t - 3;
                                                   IncR(w, Q(Kh, 3, 4, t))
                                                 END
                                            ELSE BEGIN
                                                   w:= 6 - t;
                                                   IncR(w, Q(Kh, 5, 6, t))
                                                 END;
     Result:= Round(m * w)
   END;
 
 FUNCTION Q3(s: Reel): Reel;
   VAR o, p, q, r: Reel;
   BEGIN
     o:= Sqr(0.5 * s); p:= Sqr(o); r:= 3 * p; q:= 7 - r;
     r:= p * q;        Result:= 0.25 * r
   END;
 
 FUNCTION Q2(s: Reel): Reel;                      // Variation sur [0 ; 2]
   VAR p, q, r: Reel;
   BEGIN
     r:= Sqr(0.5 * s); p:= 3 * r; q:= 5 - p;      // r = sý/4  q:= 5 - 3*sý/4
     p:= Sqr(r);       r:= p * q; Result:= 0.5 * r
   END;
 
 FUNCTION Q1(s: Reel): Reel;                      // Variation sur [0 ; 2]
   VAR p, q, r: Reel;
   BEGIN
     p:= Sqr(0.5 * s); q:= 3 - p;                 // p = sý/4 ; q = 3 - sý/4
     r:= p * q;        Result:= 0.5 * r
   END;
 
 FUNCTION Px2(t: Reel): Byte;                     // t varie de 0 … 6
   VAR w: Reel; Test1, Test2: Bool;
   BEGIN
     Test1:= ((2<t) AND (t<3));
     Test2:= ((4<t) AND (t<6));
     IF Test1 THEN w:= 1
              ELSE IF Test2 THEN w:= 0
                            ELSE IF (t<2.5) THEN BEGIN
                                                   CASE Version OF
                                                     1: w:= Q1(t);
                                                     2: w:= Q2(t);
                                                     3: w:= Q3(t)
                                                     ELSE w:= 0.5 * t  END;
                                                   IncR(w, Q(Kh/4, 0, 2, t))
                                                 END
                                            ELSE BEGIN
                                                   w:= 4 - t;
                                                   IncR(w, Q(Kh, 3, 4, t))
                                                 END;
     Result:= Round(m * w)
   END;
 
 FUNCTION Px1(t: Reel): Byte;                     // t varie de 0 … 6
   VAR w: Reel; Test1, Test2: Bool;
   BEGIN
     Test1:= ((t<2) OR  (5<t));
     Test2:= ((3<t) AND (t<4));
     IF Test1 THEN w:= 1
              ELSE IF Test2 THEN w:= 0
                            ELSE IF (t<3.5) THEN BEGIN
                                                   w:= 3 - t;
                                                   IncR(w, Q(Kh, 2, 3, t))
                                                 END
                                            ELSE BEGIN
                                                   w:= t - 4;
                                                   IncR(w, Q(Kh, 4, 5, t))
                                                 END;
     Result:= Round(m * w)
   END;
 
 FUNCTION PixelRJB(Teinte: Reel): Pixel;       // t varie de 0 … 6
   VAR Px: Pixel;
   BEGIN
     Px[1]:= Px1(Teinte); Px[2]:= Px2(Teinte);
     Px[3]:= Px3(Teinte); Result:= Px
   END;

L'initialisation de la matrice image relève de procédures ordinaires:

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
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
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Graphe des fonctions couleur
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE Axes(La, Ha: Z_32; VAR X_1, X_2, Y_1, Y_2, Dx, Dy: Z_32;
                VAR Ma: Tab_Pix);
   CONST g = 150; Pggg: Pixel = (g, g, g); Pmmm: Pixel = (m, m, m);
   VAR k: Z_32;
   BEGIN
     X_1:= Round(0.05 * La); X_2:= Round(0.95 * La); Dx:= X_2 - X_1;
     Y_1:= Round(0.05 * Ha); Y_2:= Round(0.95 * Ha); Dy:= Y_2 - Y_1;
     FOR k:= 0 TO (La - 1) DO
       BEGIN
         Ma[k, Y_1]:= Pmmm;
         IF ((X_1<k) AND (k<X_2)) THEN Ma[k, Y_2]:= Pggg
       END;
     FOR k:= 0 TO (Ha - 1) DO
       BEGIN
         Ma[X_1, k]:= Pmmm;
         IF ((Y_1<k) AND (k<Y_2)) THEN Ma[X_2, k]:= Pggg
       END
   END;
 
 PROCEDURE GrapheRJB(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST P100: Pixel = (m, 0, 0);
         P010: Pixel = (0, m, 0);
         P001: Pixel = (0, 0, m);
   VAR DeltaX, DeltaY, k, Kmax, X1, X2, Xm, Y1, Y2, Ym: Z_32;
       Cy, s, t: Reel; Px: Pixel;
   BEGIN
     Axes(Larg_Image, Haut_Image,
          X1, X2, Y1, Y2, DeltaX, DeltaY, Matr_Image);
     Kmax:= 3 * La; Cy:= DeltaY / m;
     FOR k:= 0 TO Kmax DO
       BEGIN
         t:= k / Kmax;           s:= 6 * t; Px:= PixelRJB(s);
         Xm:= Round(t * DeltaX); Inc(Xm, X1);
         Ym:= Round(Cy * Px[1]); Inc(Ym, Y1); Ma[Xm, Ym]:= P100;
         Ym:= Round(Cy * Px[2]); Inc(Ym, Y1); Ma[Xm, Ym]:= P010;
         Ym:= Round(Cy * Px[3]); Inc(Ym, Y1); Ma[Xm, Ym]:= P001
       END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Cercle chromatique
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE CalcMat_Im_C(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST I3sPi = 3 / Pi;
         Pzero: Pixel = (0, 0, 0);
   VAR Ha1, La1, Xm, Ym: Z_32; Dx, Dy, r, Rmax, s, t, w, Xc, Yc: Reel;
       Px: Pixel;
   BEGIN
     Ha1:= Ha - 1; La1:= La - 1;
     Xc:= La1 / 2; Yc:= Ha1 / 2;
     IF (Xc>Yc) THEN Rmax:= Xc ELSE Rmax:= Yc;
     FOR Xm:= 0 TO La1 DO
       BEGIN
         Dx:= Xm - Xc;
         FOR Ym:= 0 TO Ha1 DO
           BEGIN
             Dy:= Ym - Yc; r:= Norme1(Dx, Dy);
             IF (r<Rmax) THEN
               BEGIN
                 t:= Arg2XY(Dx, Dy); s:= I3sPi * t;
                 Px:= PixelRJB(s)
               END
                         ELSE Px:= Pzero;
             Ma[Xm, Ym]:= Px
           END
       END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Palette rectangulaire
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE CalcMat_Im(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST m = 255;
   VAR Ha1, La1, Xm, Ym: Z_32; r, s, w: Reel; Px: Pixel;
   BEGIN
     Ha1:= Ha - 1; La1:= La - 1;
     FOR Xm:= 0 TO La1 DO
       BEGIN
         r:= Xm / La; s:= 6 * r;
         Px:= PixelRJB(s);
         FOR Ym:= 0 TO Ha1 DO Ma[Xm, Ym]:= Px
       END
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Programme principal
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE P1;
   BEGIN
     GraphBmp(000);
//     CalcMat_Im(Larg_Image, Haut_Image, Matr_Image);
     CalcMat_Im_C(Larg_Image, Haut_Image, Matr_Image);
//     GrapheRJB(Larg_Image, Haut_Image, Matr_Image);
     Creation_F(Larg_Image, Haut_Image); A_
   END;

[wiwaxia]

Voici ce que l'on obtient dans le cas de la première fonction - polynôme Q1 du programme, appelé par l'option Version = 1:

F₁(s) = 0.5*(s/2)²*(3 - (s/2)²)

et en préservant la possibilité une modification limitée, mais continue, comme dans le programme précédent - on a repris ici h = 0 , 0.5 et 1 :

# h = 0.000

# h = 0.500

# h = 1.000

[wiwaxia]

Voici ce que l'on obtient dans le cas de la seconde fonction - polynôme Q2 du programme, appelé par l'option Version = 2:

F₂(s) = 0.5*(s/2)⁴*(5 - 3*(s/2)²)

et en reprenant toujours pour le paramètre continu les mêmes valeurs:

# h = 0.000


# h = 0.500


# h = 1.000

[wiwaxia]

Et dans le cas de la troisième - polynôme Q3 du programme, appelé par l'option Version = 3:

F₃(s) = 0.25*(s/2)⁴*(7 - 3*(s/2)⁴)

# h = 0.000


# h = 0.500


# h = 1.000

[Jipété]

Bonsoir,

Faut-il y voir un signe ?
J'ai scrupuleusement recopié tout ton code, adapté ce qui y est inconnu de Lazarus/FreePascal (reel --> real, Z_32 --> uint, bool --> boolean, bref, des détails), ai ajouté les fonctions qui manquent (je les avais par ailleurs), ai rajouté la récupération et l'affichage des pixels calculés et je gagne ça :



Tu avoueras que ce n'est pas encourageant, et je ne sais pas du tout où et quoi chercher.


De mon côté, ce matin à la fraîche j'ai attaqué la rédaction de ce qui suit :

+++

L'œil n'est pas fiable, ou plutôt, les interprétations du cerveau

Bonjour,

à force de chercher la couleur exacte, j'ai découvert avec stupéfaction, grâce au petit outil en haut à droite (voir image + bas) qui me permet de changer R,G,B de chaque colonne, qu'après avoir défini aux mêmes valeurs deux colonnes côte à côte mon cerveau m'envoyait deux impressions différentes !
Hé oui…
Et à l'inverse, des valeurs bien différentes me donnaient l'impression de voir la même teinte.

À partir de là, je considère qu'on ne peut se baser sur rien de précis et de fiable en ce qui concerne ce qu'on voit et ce qu'on croit voir.

Tout est susceptible d'interprétations non contrôlées et non contrôlables.

Je propose qu'on en reste là, car même si wiwaxia nous trouve la formule qui va bien avec les sigmoïdes, on ne saura pas si c'est bien ou pas.



L'image ci-dessus (réduite de moitié) satisfait mon œil, que demander de plus ?

La palette finale (pour moi, pour aujourd'hui) :

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
 R   G   B
230;006;025;
247;034;007;
252;062;005;
254;092;003;
251;123;002;
248;155;002;
245;172;002;
231;193;004;
220;210;006;
190;222;010;
147;237;020;
104;246;040;
042;243;073;
018;216;125;
012;172;190;
013;130;235;
015;096;246;
028;073;252;
042;051;245;
061;032;238;
093;024;217;
124;017;195;
155;012;135;
185;010;075;

+++
Je n'ai pas posté ce qui précède, je n'étais pas prêt, et en fin d'après-midi j'ai rajouté ça :
+++
Et cette palette, passée au programme qui sait dessiner les courbes des valeurs des teintes, donne ça :



et la première chose qu'on remarque, après la beauté spectaculaire de la boule de billard, c'est la répartition chaotique des 3 courbes, avec des zones plates et des angles violents.
Oui.
C'est ce qui permet d'avoir ces superbes teintes dans le dégradé horizontal.

Que dire de plus ? Qu'il y a un peu trop de bleu, au détriment du vert et du cyan ? Ce n'est pas faux, mais ce matin ça ne se voyait pas, et j'ai bien dit plus haut, à propos de la palette finale, (pour moi, pour aujourd'hui).
+++

Et je venais de terminer cette rédaction quand ma messagerie m'a annoncé l'arrivée de ton post, que je suis allé voir toutes affaires cessantes (mais c'était très bien, je venais juste de finir [j'adôôôre ces coïncidenses]), et on peut en lire le compte-rendu tout en haut.

Je susi bien obligé de reconnaître que tes résultats sont très jolis, sauf qu'il y manque le dégradé blanc->couleur->noir, ainsi qu'un affichage horizontal pour bien se rendre compte.

[wiwaxia]

... à force de chercher la couleur exacte, j'ai découvert avec stupéfaction, grâce au petit outil en haut à droite (voir image + bas) qui me permet de changer R,G,B de chaque colonne, qu'après avoir défini aux mêmes valeurs deux colonnes côte à côte mon cerveau m'envoyait deux impressions différentes !
Hé oui…
Et à l'inverse, des valeurs bien différentes me donnaient l'impression de voir la même teinte.

À partir de là, je considère qu'on ne peut se baser sur rien de précis et de fiable en ce qui concerne ce qu'on voit et ce qu'on croit voir.

Tout est susceptible d'interprétations non contrôlées et non contrôlables ...

Ce sujet a été évoqué à maintes reprises: la perception des couleurs est extrêmement sensible, mais pas du tout fidèle (comme d'ailleurs les autres sens); on le sait depuis longtemps, et l'on sait bien gérer les illusions d'optique.

Les raies anormalement brillantes en sont justement une, et leur cause est avérée: il s'agit des discontinuités de pente que présentent les fonctions commandant la distribution des couleurs.
Le problème a été réglé pour les palettes à une dimension, dans lesquelles la teinte locale de dépend que d'un seul paramètre; bien sûr, les solutions proposées ne sont pas uniques, mais les contraintes qu'elles doivent vérifier sont clairement identifiées.

... L'image ci-dessus (réduite de moitié) satisfait mon œil, que demander de plus??
La palette finale (pour moi, pour aujourd'hui) ...
... / ...
et la première chose qu'on remarque, après la beauté spectaculaire de la boule de billard, c'est la répartition chaotique des 3 courbes, avec des zones plates et des angles violents.
Oui. C'est ce qui permet d'avoir ces superbes teintes dans le dégradé horizontal ...

Tu as en fait repris le spectre chromatique de la lumière blanche, qui est apériodique et ne se prête pas à une présentation cyclique. Et l'interprétation que tu en donnes est sujette à caution.
Ce qui n'empêche pas que la palette linéaire est en soi agréable à regarder.

Mais il y a là dessous un sujet que tu n'as jamais voulu aborder franchement: le passage d'une liste finie de couleurs à un dégradé continu de teintes. Je pense (peut-être à tort ?) que tu a usé (et abusé) d'expédients qui ont parfois conduit à des résultats désastreux, d'autant plus surprenants compte tenu de la puissance des moyens utilisée (Free Pascal et Lazarus); et GIF a servi de bouc émissaire.

... Je suis bien obligé de reconnaître que tes résultats sont très jolis, sauf qu'il y manque le dégradé blanc->couleur->noir, ainsi qu'un affichage horizontal pour bien se rendre compte ...

On ne peut résoudre qu'un seul problème à la fois, et les questions auxquelles j'ai tenté de répondre (éclairements uniformes, palettes RJB) ont conduit à des développements assez longs.

Il manquait la programmation de l'évolution transversale des teintes vers le noir et le blanc: voilà qui vient d'être fait.

[wiwaxia]

On peut envisager plusieurs sortes d'expressions pour la fonction recherchée I = F(I°, z):

1°) Une fonction linéaire en deux morceaux, dont la rupture de pente à la limite des deux domaines (z = 1/2) conduit à une zone étroite anormalement brillante (ligne ou cercle).

2°) Une fonction continument dérivable, exempte du défaut précédent, dont le graphe résulte du raccordement à tangentes confondues de deux arcs de parabole; elle est représentée par deux polynômes su second degré.

3°) Une fonction continument dérivable présentant de plus deux tangentes horizontales aux points d'abscisses (z = 1/2) et (z = 1), ce qui a pour effet d'étaler le domaine de la couleur médiane (z ~ 1/2) et celui du blanc (pour z ~ 1).

Voici les palettes rectangulaires correspondant à chacune de ces fonctions - on a repris d'une manière systématique la dernière des distributions (RJB) des couleurs définies dans les messages #304, #305, #306 et #307: h = 1.000 , version 3 .

# D'abord, trois les palettes rectangulaires:

Remarquer la ligne horizontale brillante que présente la première, et seule - en illustration de ce qui a été dit au-dessus.

# Ensuite les graphes des coefficients, et les cercles chromatiques correspondants:

# Pour la fonction linéaire par morceaux (degré = 1):



# Pour la fonction constituée de polynômes du 2nd degré:



# Pour la fonction comportant un polynôme de degré 3:

# Le programme source explicite les trois fonctions utilisées:

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
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
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Transformation du noir au blanc
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 FUNCTION F2deg3(h, z: Reel): Reel;                  // u = z - 1; v = 2*z - 1
   VAR K2, p, q, r, Z2, u, v, w: Reel;            // w = 4*z - 3; q:= u*v*w
   BEGIN
     v:= 4 * z; w:= v - 3;      u:= z - 1;       v:= u + z;
     p:= u * v; q:= p * w;      p:= 1 - h;       K2:= 2 * p;
     w:= h;     IncR(w, p * v); DecR(w, K2 * q); Result:= w
   END;        // w = h + (1-h)*(2z - 1) + 2(1 - h)(z - 1)(2z - 1)(4z - 3)
 
 FUNCTION F1deg3(h, z: Reel): Reel;    // w = h(1 - (2z - 1)²)
   VAR p, q, r: Reel;
   BEGIN
     p:= 2 * z; q:= Sqr(p - 1); r:= 1 - q;
     Result:= h * r
   END;
 
 FUNCTION F2deg2(h, z: Reel): Reel;   // K2 = (2 - 2*h)*(1 - 2*h)
   VAR K2, p, q, r, Z2, w: Reel;  // w = h + (1-h)*(2*z-1) - K2*(1-z)(2*z-1)
   BEGIN
     q:= 2 * h;  p:= 2 - q;  q:= p - 1; K2:= p * q;
     Z2:= 2 * z; r:= Z2 - 1; w:= h;
     p:= 1 - h;  IncR(w, p * r);
     p:= 1 - z;  q:= K2 * p; DecR(w, q * r);
     Result:= w
   END;
 
 FUNCTION F1deg2(h, z: Reel): Reel;   // K1 = 2*h*(2*h - 1)
   VAR K1, p, q, Z2, w: Reel;     // w = h*(2*z) + K1*z*(1 - 2*z)
   BEGIN
     p:= 2 * h;  q:= p - 1;  K1:= p * q;
     Z2:= 2 * z; w:= h * Z2;
     p:= K1 * z; q:= 1 - Z2; IncR(w, p * q);
     Result:= w
   END;
 
 FUNCTION F2deg1(h, z: Reel): Reel;
   VAR K2, p, q, r, Z2, w: Reel;
   BEGIN
     p:= 2 * z;       q:= p - 1;
     r:= q * (1 - h); Result:= h + r
   END;
 
 FUNCTION F1deg1(h, z: Reel): Reel;
   VAR p: Reel;
   BEGIN
     p:= 2 * z; Result:= h * p
   END;
 
 FUNCTION CoeffNB(Vm, d: Reel): Reel;
   VAR w: Reel;
   BEGIN
     IF (d=0.5) THEN w:= Vm
                ELSE IF (d<0.5) THEN w:= F1deg1(Vm, d)
                                ELSE w:= F2deg1(Vm, d);
     Result:= w
   END;

... et à titre indicatif les instructions de codage des graphes des coefficients:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
 PROCEDURE Axes(La, Ha: Z_32; VAR X_1, X_2, Y_1, Y_2, Dx, Dy: Z_32;
                VAR Ma: Tab_Pix);
   CONST g = 120; Pggg: Pixel = (g, g, g); Pmmm: Pixel = (m, m, m);
   VAR k, Xmed: Z_32;
   BEGIN
     X_1:= Round(0.05 * La); X_2:= Round(0.95 * La); Dx:= X_2 - X_1;
     Y_1:= Round(0.05 * Ha); Y_2:= Round(0.95 * Ha); Dy:= Y_2 - Y_1;
     Xmed:= Round(0.5 * La);
     FOR k:= 0 TO (La - 1) DO
       BEGIN
         Ma[k, Y_1]:= Pmmm;
         IF ((X_1<k) AND (k<X_2)) THEN Ma[k, Y_2]:= Pggg
       END;
     FOR k:= 0 TO (Ha - 1) DO
       BEGIN
         Ma[X_1, k]:= Pmmm;
         IF ((Y_1<k) AND (k<Y_2)) THEN BEGIN
                                         Ma[X_2, k]:= Pggg;
                                         Ma[Xmed, k]:= Pggg
                                       END
       END
   END;
 
 CONST n = 153; IcMax = 10;
       Couleur: ARRAY[0..IcMax] OF Pixel = ((n, 0, 0),
                 (m, 0, 0), (m, n, 0), (n, m, 0),
                 (0, m, 0), (0, m, n), (0, n, m),
                 (0, 0, m), (n, 0, m), (m, 0, n), (n, 0, n));
 
 PROCEDURE GrapheNoirBlanc(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST P100: Pixel = (m, 0, 0);
         P010: Pixel = (0, m, 0);
         P001: Pixel = (0, 0, m);
   VAR i: Byte; DeltaX, DeltaY, k, Kmax, X1, X2, Xm, Y1, Y2, Ym: Z_32;
       Kc, s, t: Reel;
   BEGIN
     Axes(Larg_Image, Haut_Image,
          X1, X2, Y1, Y2, DeltaX, DeltaY, Matr_Image);
     Kmax:= 3 * La;
     FOR k:= 0 TO Kmax DO
       BEGIN
         t:= k / Kmax; Xm:= Round(t * DeltaX); Inc(Xm, X1);
         FOR i:= 0 TO IcMax DO
           BEGIN
             Kc:= CoeffNB(0.1 * i, t); Ym:= Round(DeltaY * Kc);
             Inc(Ym, Y1);              Ma[Xm, Ym]:=Couleur[i]
           END
       END
   END;

[Jipété]

Salut,

Mais il y a là dessous un sujet que tu n'as jamais voulu aborder franchement: le passage d'une liste finie de couleurs à un dégradé continu de teintes. Je pense (peut-être à tort ?) que tu a usé (et abusé) d'expédients qui ont parfois conduit à des résultats désastreux, d'autant plus surprenants compte tenu de la puissance des moyens utilisée (Free Pascal et Lazarus); et GIF a servi de bouc émissaire.

comme ça m'épuise que tu rabaches ça sans arrêt, on va faire une mise au point définitive sur ce sujet :
je pars d'un programme dans lequel j'étudie la répartition et les écarts de teinte à la main (avec les curseurs), et voilà un cercle à l'intant t, récupéré avec The Gimp à qui j'ai demandé une "copie d'écran en sélectionnant la zone à la souris", image que j'ai exportée telle quelle en png sans toucher à aucune option :


Ensuite j'ai juste redimensionné l'image aux deux-tiers (390 -> 260) et réexportée dans un autre fichier :


puis je l'ai exportée en demandant jpg et une compression à 80 % :


et enfin une exportation en gif, sans aucune animation puisqu'il n'y a qu'une image, et voilà la catastrophe :


Depuis le début je te répète que la norme gif ne peut gérer que 256 couleurs, il faut donc bien que The Gimp en fasse sauter pour faire le boulot d'export, et c'est ce qu'on voit.

Pour le reste je n'ai pas encore regardé.

[Jipété]

Il n'a pas été nécessaire de chercher loin pour trouver quelques fonctions simples apportant les modifications souhaitées, et dont l'ajustement est à la portée d'un élève de première.

Mais il doit en manquer une : je constate que Lazarus n'est pas satisfait du tout de ta fonction GrapheRJB, comme on peut le lire ci-dessous :


En effet, on va appeler Axes avec des variables non utilisées (soulignées par des vaguelettes en orange), ça ne peut pas le faire !

Et je ne suis pas devin, et ma boule de cristal est cassée…

PS : je n'ai pas compris pourquoi j'ai trouvé plusieurs fois les noms Larg_Image et Haut_Image quand les fonctions et procédures ne connaissent que La et Ha, d'où mon adaptation -- tu ne nous aurais pas mélangé les sources, par hasard ?

[wiwaxia]

Mais il doit en manquer une : je constate que Lazarus n'est pas satisfait du tout de ta fonction GrapheRJB, comme on peut le lire ci-dessous :
... / ...
En effet, on va appeler Axes avec des variables non utilisées (soulignées par des vaguelettes en orange), ça ne peut pas le faire !
Et je ne suis pas devin, et ma boule de cristal est cassée …

Les six variables en question sont initialisées dans la procédure Axes(...) par des calculs apparentés ou interdépendants; on aurait tort de se priver de cette facilité.

Code :

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

1
2
3
4
5
6
7
 PROCEDURE Axes(La, Ha: Z_32; VAR X_1, X_2, Y_1, Y_2, Dx, Dy: Z_32;
                VAR Ma: Tab_Pix);
   CONST g = 120; Pggg: Pixel = (g, g, g); Pmmm: Pixel = (m, m, m);
   VAR k, Xmed: Z_32;
   BEGIN
     X_1:= Round(0.05 * La); X_2:= Round(0.95 * La); Dx:= X_2 - X_1;
     Y_1:= Round(0.05 * Ha); Y_2:= Round(0.95 * Ha); Dy:= Y_2 - Y_1; ...

Et je me demande bien comment le programme aurait pu fonctionner: l'oubli d'une affectation est une erreur qui ne pardonne pas.

... PS : je n'ai pas compris pourquoi j'ai trouvé plusieurs fois les noms Larg_Image et Haut_Image quand les fonctions et procédures ne connaissent que La et Ha, d'où mon adaptation -- tu ne nous aurais pas mélangé les sources, par hasard ?

Oh, certainement pas ! S'il y a une partie du code immuable, c'est bien celle_là !

Larg_Image, Haut_Image, Matr_Image désignent des variables globales définies dans l'unité Bitmap; les identificateurs ont été délibérément choisis longs, afin d'éviter toute méprise dans le développement du programme.
La, Ha désignent les variables locales correspondantes, qui reçoivent les valeurs des dimensions de l'image, après saisie de ces dernières.

L'appel d'une procédure utilise les variables globales, comme tu peux le voir ci-dessous:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 PROCEDURE P1;
   BEGIN
     GraphBmp(0);
//     GrapheNoirBlanc(Larg_Image, Haut_Image, Matr_Image);
     CalcMat_Im(Larg_Image, Haut_Image, Matr_Image);
//     CalcMat_Im_C(Larg_Image, Haut_Image, Matr_Image);
//     GrapheRJB(Larg_Image, Haut_Image, Matr_Image);
     Creation_F(Larg_Image, Haut_Image); A_
   END;
 
 BEGIN
   P1
 END.

La conception du programme principal est assez fruste, en raison des multiples variantes que les échanges sur forum incitent à coder.
L'instruction de la ligne (5), par exemple, renvoie à

Code :

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

PROCEDURE CalcMat_Im(La, Ha: Z_32; VAR Ma: Tab_Pix); ... / ...

Les variables locales doivent recevoir un nom différent de celui de la variable globale associée; il faut faire court, afin de préserver la lisibilité des calculs; mais choisir un nom en rapport direct avec celui de la variable globale pour soulager l'effort de mémoire.

J'ai l'impression de faire des rappels de Basic Pascal.

[Jipété]

J'ai l'impression de faire des rappels de Basic Pascal.

Et moi j'ai l'impression que des fois on me prend pour le dernier des benêts…

Larg_Image, Haut_Image, Matr_Image désignent des variables globales définies dans l'unité Bitmap;

Unité que nous n'avons pas.
Bien c'que j'disais, il nous manque quelque chose :

[wiwaxia]

... Unité que nous n'avons pas ...

C'est une unité personnelle.
J'ai clairement dit, il y a une quinzaine de pages, que tu devais toi-même prendre en charge la gestion de la matrice image.
Et je me rappelle que tu avais fait le lien, en d'autres circonstances, entre cette matrice et les variables de type T_Bitmap de Lazarus & C^ie.

... Bien c'que j'disais, il nous manque quelque chose ...

Allez, pas de mauvais esprit. Je posterai l'unité, s'il le faut.

PS: Voir #44, #46

[Jipété]

J'ai clairement dit, il y a une quinzaine de pages, que tu devais toi-même prendre en charge la gestion de la matrice image.
Et je me rappelle que tu avais fait le lien, en d'autres circonstances, entre cette matrice et les variables de type T_Bitmap de Lazarus & C^ie.

Oui, c'est ce que j'ai fait, mais là, les choses ont changé.

J'ai bien retrouvé en page 46 (il y a 45 jours ! Tu penses comme les choses ont évolué depuis.) tes dimensions 0..2000 pour la matrice, mais ça ne suffit pas car, quand je regarde tes copies d'écran, je vois des images rectangulaires pour les courbes et des images carrées pour les cercles dégradés, et rien qui me dit comment tout cela est organisé à partir des codes fournis.

Je suis donc dans l'incapacité totale de raccorder les morceaux.

J'en suis là et ne pourrais pas aller plus loin sans autres précisions.

Allez, pas de mauvais esprit. Je posterai l'unité, s'il le faut.

Des détails suffiraient.

[wiwaxia]

Contenu supprimé. Documentation trop volumineuse.

[Jipété]

Je n'ai pas le temps de faire le tri de ce qui est utile dans les unités satellites:

Et moi je n'ai absolument pas le temps de démonter tout ton programme pour comprendre comment il fonctionne, d'autant plus qu'avec ses codes j'aurais l'impression de retourner à la préhistoire de la programmation, par exemple ta procédure d'enregistrement d'un fichier bitmap et sa cinquantaine (à la louche) de lignes réparties entre plusieurs fonctions et procédures quand FreePascal et Lazarus nous proposent bitmap.SavetoToFile(chemin + 'nom_de_fichier');. Le monde a évolué, hein.

Alors OK, tu as réussi à écrire des procédures cauchemardesques et des fonctions hallucinantes, qui produisent les fichiers que tu attendais, mais je ne vais pas pouvoir les utiliser car même si j'arrivais à faire fonctionner cette usine à gaz, je serais bien incapable de la maintenir, la preuve avec la petite image que j'ai postée, pour laquelle je vois pas par quel bout prendre le problème.

Par exemple, j'ai signalé en début d'après_midi la non-initialisation de la variable deltaX (parmi d'autres) et ce soir le problème reste entier car dans les codes que tu as postés j'ai fait une recherche sur ce mot, recherche qui n'a pas abouti.
À partir de là, impossible d'avancer.


Et au bout du compte, pourquoi se prendre la tête avec des fonctions mathématiques aux noms imprononçables quand, de toute façon, il faudra, une fois la matrice générée, faire des retouches à la main pour éliminer les surbrillances, mmmh ? Autant attaquer directement avec mes 24x3 curseurs.

[Jipété]

Et pendant que je te tiens et puisqu'il y a zéro commentaire dans tes codes, auras-tu la bonté d'expliquer

Code pascal :

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

1
2
3
4
5
6
 FUNCTION Hypothenuse(u, v, w: Reel): Reel;
   VAR s, t, U2, V2, W2: Reel;
   BEGIN
     U2:= Sqr(u); V2:= Sqr(v); W2:= Sqr(w);
     s:= U2+ V2;  t:= s + W2;  Hypothenuse:= Sqrt(t)
   END;

parce que pour moi, à partir du moment où le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, on devrait s'en sortir avec

Code pascal :

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

1
2
     U2:= Sqr(u); V2:= Sqr(v); {W2:= Sqr(w);}
     s:= U2+ V2;  {t:= s + W2;}  Hypothenuse:= Sqrt(s)

(je te laisse le "h" là mais normalement il n'y en a plus :

L’ajout d’un « h » est une hypercorrection étymologiquement injustifiée et ici des trucs en grec, suivez le lien dessous pour lire la suite

)
Voili voilou,

+++
Obligé de poster en deux morceaux, parce qu'en un seul j'ai gagné ça :

Première fois de ma vie que je vois ça depuis que je suis inscrit…
Et en fait, ça a l'air lié à du texte où il y a des lettres grecques (je ne vois que ça) venant de là par copier/coller.

[wiwaxia]

Et moi je n'ai absolument pas le temps de démonter tout ton programme pour comprendre comment il fonctionne, d'autant plus qu'avec ses codes j'aurais l'impression de retourner à la préhistoire de la programmation, par exemple ta procédure d'enregistrement d'un fichier bitmap et sa cinquantaine (à la louche) de lignes réparties entre plusieurs fonctions et procédures quand FreePascal et Lazarus nous proposent bitmap.SavetoToFile(chemin + 'nom_de_fichier');. Le monde a évolué, hein.

Alors OK, tu as réussi à écrire des procédures cauchemardesques et des fonctions hallucinantes, qui produisent les fichiers que tu attendais, mais je ne vais pas pouvoir les utiliser car même si j'arrivais à faire fonctionner cette usine à gaz, je serais bien incapable de la maintenir, la preuve avec la petite image que j'ai postée, pour laquelle je vois pas par quel bout prendre le problème ...

1) Il ne t'était pas demandé de lire et de comprendre la partie implémentation. Il s'agissait d'exécuter deux procédures de l'interface, rien de plus.
Maintenant, pour ce qui est de la préhistoire, les fichiers Bitmap sont restés ce qu'ils étaient, et tes logiciels effectuent d'une manière cachée (c à d en code exécutable) une tâche analogue à celle dont tu as pu parcourir le code source. Il faut dans un cas comme dans l'autre gérer les 54 octets constituant l'entête; et l'unité fonctionnant correctement, je ne m'attarde plus depuis longtemps à ces détails.

2) Si tu avais eu la curiosité de compiler l'usine à gaz en question avec le petit programme que je proposais, tu aurais été confronté à la vision insoutenable de la fenêtre suivante:



propre, il est vrai, à démoraliser le plus aguerri des programmeurs développeurs .

... Par exemple, j'ai signalé en début d'après_midi la non-initialisation de la variable deltaX (parmi d'autres) et ce soir le problème reste entier car dans les codes que tu as postés j'ai fait une recherche sur ce mot, recherche qui n'a pas abouti ...

J'ai cité les instructions d'initialisation; si tu ne comprends toujours pas, c'est que tu as de gros problèmes avec la programmation en général, et le langage Pascal en particulier ... Ce n'est plus du ressort de la rationalité.

... Et au bout du compte, pourquoi se prendre la tête avec des fonctions mathématiques aux noms imprononçables quand, de toute façon, il faudra, une fois la matrice générée, faire des retouches à la main pour éliminer les surbrillances, mmmh ? Autant attaquer directement avec mes 24x3 curseurs.

Les surbrillances ont précisément été éliminées à l'aide de fonctions paramétrées, permettant de régler l'évolution des teintes ... Je ne compte plus les séries d'algorithmes et d'images qui ont été proposées, ne demandant aucune retouche manuelle.

... Et pendant que je te tiens et puisqu'il y a zéro commentaire dans tes codes, auras-tu la bonté d'expliquer

Code pascal :

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

1
2
3
4
5
6
 FUNCTION Hypothenuse(u, v, w: Reel): Reel;
   VAR s, t, U2, V2, W2: Reel;
   BEGIN
     U2:= Sqr(u); V2:= Sqr(v); W2:= Sqr(w);
     s:= U2+ V2;  t:= s + W2;  Hypothenuse:= Sqrt(t)
   END;

parce que pour moi, à partir du moment où le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, on devrait s'en sortir avec

Code pascal :

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

1
2
     U2:= Sqr(u); V2:= Sqr(v); {W2:= Sqr(w);}
     s:= U2+ V2;  {t:= s + W2;}  Hypothenuse:= Sqrt(s)

(je te laisse le "h" là mais normalement il n'y en a plus).

Cette fonction de 3 variables résulte de la généralisation du théorème de Pythagore à l'espace à 3 dimensions; elle n'est d'aucune utilité dans le plan. Un minimum de réflexion t'aurait permis de voir qu'elle n'intervient pas dans les calculs actuels.

L'intelligence, c'est comme la liberté de la presse, elle ne s'use que si l'on ne s'en sert pas.