Discussion :

[Jipété]

et il n'y a pas pire sourd que celui qui ne veut rien comprendre.

Ce n'est pas faute d'avoir essayé, mais quand il manque des éléments je peux toujours lever le doigt, personne ne m'entend,
En plus, tu déformes le proverbe :
il n'y a pas pire sourd que celui qui ne veut rien entendre, nuance !
Comprendre c'est autre chose.

Quand, comme je l'ai dit, je lis dans un des bouquins que "Le coefficient alpha que l'on peut supposer positif (en changeant si besoin est alpha en alpha + ou - PI)", c'est ce "peut supposer" qui me rend perplexe : si l'auteur avait écrit "que l'on doit utiliser", j'aurais avancé.
Là je lis, je tourne dans tous les sens, j'entends et ne comprends pas.

Je sais seulement que les teintes (R, V, B) se succèderont dans l'ordre opposé.

Ben non, elles se succèdent de la même manière -- sinon je n'aurais pas posté ce truc-là : je me suis battu comme un beau diable pour avoir rouge-vert-bleu bien affiché, quel intérêt aurais-je eu à pondre un algo qui ne les affiche pas ainsi ?

C'est bien ce que je dis : je ne suis pas lu, ou pas bien, ou pas compris, alors que je me décarcasse à mettre des copies d'écran. Mais dans ce cas, ce n'est pas la peine, ça serait deux fois la même.

Et c'est curieux que tu ne reconnaisses pas tes sources, car c'est pourtant de ça que je suis parti :

Code :

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

1
2
3
        r := fx_jpt(Phi, fx);
        g := fx_jpt(Phi - Pi2sur3, fx);
        b := fx_jpt(Phi - D_Pi2sur3, fx);

Sauf que j'ai très vite été perturbé par le fait que pour parcourir dans le sens trigo (la flèche, le "+"), il faut utiliser le signe "-", un peu comme sur l'Estafette, qui a la même boîte de vitesse que toutes les bagnoles, mais montée à l'envers : la 1^re est en bas, ça surprend…

Mais bon, on y est arrivé, j'ai ma boîte noire, après tout, quand Mââme Michu va faire ses courses, avec sa 'tit'auto, elle ne se prend pas la tête pour savoir dans quel sens tourne le vilebrequin dans la culasse moteur, le tout c'est que quand elle passe la 1^re ça avance !

+++

Essaie d'afficher comme moi les valeurs réelles de ta fonction: on verra bien ce qui se passe.

J'ai affiché les tiennes avec la maintenant classique ligne de log à la fin de

Code :

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

1
2
3
4
PROCEDURE TFormB.CalcMatrIm(La, Ha: uint; fx: uint);
...
  memo1.Lines.Add(format('Ym: %.3d, Xm: %.3d, r: %.3d, g: %.3d, b: %.3d',[Ym, Xm, r, g, b]));
end;

, ça donne ça (juste le début, et édité) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
1er bloc, rouge à jaune
Ym: 000, Xm: 000, r: 255, g: 000, b: 000 rouge pur
Ym: 000, Xm: 001, r: 255, g: 001, b: 000 le vert commence à monter
...
Ym: 000, Xm: 127, r: 255, g: 127, b: 000
Ym: 000, Xm: 128, r: 255, g: 128, b: 000 
Ym: 000, Xm: 129, r: 255, g: 128, b: 000 il est là le souci : "g: 128" ligne précédente = OK, encore ici = bad
Ym: 000, Xm: 130, r: 255, g: 129, b: 000
...
Ym: 000, Xm: 254, r: 255, g: 253, b: 000
Ym: 000, Xm: 255, r: 255, g: 254, b: 000

et du coup tout le vert est décalé à partir de Xm à 129, on devrait ici (ligne 11) être à r: 255 g: 255

Et pareil pour les morceaux suivants.

En ce qui concerne ma manière de faire, j'ai aussi des lignes en double, elles se situent plus loin, par exemple en ligne 14, doublon de la 11

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
1er bloc, rouge à jaune
Ym: 000, Xm: 000, r: 255, g: 000, b: 000 rouge pur
Ym: 000, Xm: 001, r: 255, g: 001, b: 000 le vert commence à monter
...
Ym: 000, Xm: 127, r: 255, g: 127, b: 000
Ym: 000, Xm: 128, r: 255, g: 128, b: 000 
Ym: 000, Xm: 129, r: 255, g: 129, b: 000 ici défaut wwx
Ym: 000, Xm: 130, r: 255, g: 130, b: 000
...
Ym: 000, Xm: 254, r: 255, g: 254, b: 000
Ym: 000, Xm: 255, r: 255, g: 255, b: 000 rouge et vert à bloc = jaune
 
2e bloc, jaune à vert 
Ym: 000, Xm: 256, r: 255, g: 255, b: 000 encore à jaune
Ym: 000, Xm: 257, r: 254, g: 255, b: 000 le rouge descend
...

Et ça a l'air très compliqué de faire sauter ces lignes en double

Voilà mon truc,

Code :

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

1
2
3
4
5
6
if (Xm >= 0)    and (Xm < 256)  then begin r:=255;     g:=Xm;      b:=0;      end;
if (Xm >= 256)  and (Xm < 512)  then begin r:=511-Xm;  g:=255;     b:=0;      end;
if (Xm >= 512)  and (Xm < 768)  then begin r:=0;       g:=255;     b:=Xm-512; end;
if (Xm >= 768)  and (Xm < 1024) then begin r:=0;       g:=1023-Xm; b:=255;    end;
if (Xm >= 1024) and (Xm < 1280) then begin r:=Xm-1024; g:=0;       b:=255;    end;
if (Xm >= 1280) and (Xm < 1536) then begin r:=255;     g:=0;       b:=1535-Xm;end;

[Jipété]

Et ça a l'air très compliqué de faire sauter ces lignes en double

Bah, pas tant que ça, en fait : juste ajouter une variable qui va permettre d'avancer autrement dans le tableau des couleurs :

Code :

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

1
2
3
4
5
6
if (Xm >= 0)    and (Xm < 256)  then begin r:=255;      g:=ptr;      b:=0;        inc(ptr); end;
if (Xm >= 256)  and (Xm < 511)  then begin r:=510-ptr;  g:=255;      b:=0;        inc(ptr); end;
if (Xm >= 511)  and (Xm < 766)  then begin r:=0;        g:=255;      b:=ptr-510;  inc(ptr); end;
if (Xm >= 766)  and (Xm < 1021) then begin r:=0;        g:=1020-ptr; b:=255;      inc(ptr); end;
if (Xm >= 1021) and (Xm < 1276) then begin r:=ptr-1020; g:=0;        b:=255;      inc(ptr); end;
if (Xm >= 1276) and (Xm < 1531) then begin r:=255;      g:=0;        b:=1530-ptr; inc(ptr); end;

le résultat, ultra édité, donne ça (j'ai rajouté des signes + et - pour se repérer dans ce qui se passe) :

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
Ym: 000, Xm:  000, r: 255, g: 000, b: 000
                               +
Ym: 000, Xm:  255, r: 255, g: 255, b: 000
                       -
Ym: 000, Xm:  510, r: 000, g: 255, b: 000
                                       +
Ym: 000, Xm:  765, r: 000, g: 255, b: 255
                               -
Ym: 000, Xm: 1020, r: 000, g: 000, b: 255
                       +
Ym: 000, Xm: 1275, r: 255, g: 000, b: 255
                                       -
Ym: 000, Xm: 1529, r: 255, g: 000, b: 001
 
6 lignes identiques à supprimer
Ym: 000, Xm: 1530, r: 255, g: 000, b: 000 identique à ligne 0
...
Ym: 000, Xm: 1535, r: 255, g: 000, b: 000

Donc les 6 dernières lignes sont à supprimer, du coup l'image finale passe de 1536 colonnes à 1530 (le 1^er morceau reste à 256 pixels [0 à 255], et les 5 autres passent à 255 pixels car le dernier d'un morceau est le premier du morceau suivant), et ça fonctionne tout aussi bien, et sans aucun doublon.

Par contre, je ne sais pas ce que ça vaut…
(mais ça va me faire intensément réfléchir à des anciens projets basés sur des images de 1536 px de large.)

[Jipété]

Bonjour,

la nuit portant conseil, je peux me séparer de la variable intermédiaire ainsi :

Code :

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

1
2
3
4
5
6
if (Xm >= 1)    and (Xm < 256)  then begin r:=255;     g:=Xm;      b:=0;       end;
if (Xm >= 256)  and (Xm < 511)  then begin r:=510-Xm;  g:=255;     b:=0;       end;
if (Xm >= 511)  and (Xm < 766)  then begin r:=0;       g:=255;     b:=Xm-510;  end;
if (Xm >= 766)  and (Xm < 1021) then begin r:=0;       g:=1020-Xm; b:=255;     end;
if (Xm >= 1021) and (Xm < 1276) then begin r:=Xm-1020; g:=0;       b:=255;     end;
if (Xm >= 1276) and (Xm < 1531) then begin r:=255;     g:=0;       b:=1530-Xm; end;

et après avoir ajouté 1 ligne au début du balayage :

Code :

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

1
2
  FOR Ym:= 0 TO Ha1 DO begin
    r:=255; g:=0; b:=0; // initialise les 3 teintes

ça donne ça :

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
Xm: 0000, r: 255, g: 000, b: 000
                      + le vert monte
Xm: 0255, r: 255, g: 255, b: 000
              - le rouge descend
Xm: 0510, r: 000, g: 255, b: 000
                              + le bleu monte
Xm: 0765, r: 000, g: 255, b: 255
                      - le vert descend
Xm: 1020, r: 000, g: 000, b: 255
              + le rouge monte
Xm: 1275, r: 255, g: 000, b: 255
                              - le bleu descend
Xm: 1530, r: 255, g: 000, b: 000
... 6 lignes identiques à la première
Xm: 1535, r: 255, g: 000, b: 000

Les plus observateurs noteront que les 6 dernières lignes sont identiques et inévitables, à moins de raboter le bitmap une fois sa génération terminée.

Ça serait facile mais je ne sais pas trop s'il faut faire ainsi, dans la mesure où, lorsque je travaille sur des maquettes, j'utilise souvent des valeurs bien divisibles par 2 pour les largeurs d'image et là, on se retrouverait avec 1530 qui, une fois divisé par 2, donne 765 et on ne va guère plus loin.
Alors qu'avec 1536, / 2 = 768 / 2 = 384 / 2 = 192 / 2 = 96 / 2 = 48 etc., ça en fait des essais possibles.

Par 3 c'est bien aussi :
1530 / 3 = 510 / 3 = 170 / 3 =
1536 / 3 = 512 / 3 = , ok ok, mais
1530 / 3 = 510 / 2 = 255
1536 / 3 = 512 / 2 = 256 / 2 = 128 / 2 = 64 / 2 = 32, 16, 8, 4, 2, 1 c'est + sympa

Alors en fonction de ses besoins propres, chacun adaptera.

Je crois qu'on a fait le tour.
Bon dimanche, et si pas de bug de dernière minute, le zip en fin de journée ?

[Jipété]

Bon dimanche, et si pas de bug de dernière minute, le zip en fin de journée ?

Voilà donc le zip, qu'il suffira de télécharger, cliquer-droit puis "extraire ici", et ça générera le dossier qui va bien : palettes_rgb_ryb.zip

Quelques notes et remarques (il y en a encore un tout petit peu au début de l'unité principale) :

- La partie droite de la fenêtre a une particularité, c'est qu'en cas de resize elle s'adapte en faisant en sorte que sa largeur centrale utile (moins deux marges fixes de 12 et 12 ou 13 pixels) soit divisible par 24, une vieille histoire que je n'ai pas eu le courage de remettre à plat (c'est une maquette de travail et d'étude, pas le programme_de_la_mort_qui_tue à diffuser au monde entier).

- Les gens sous Windows-Delphi devront adapter quelques bricoles, genre renommer le .lfm en .dfm et l'éditer avec le Bloc-notes car on y trouve dedans, au début, la version de Lazarus et je ne sais pas du tout comment se comporte une version actuelle de Delphi vis-à-vis de choses incongrues.

- Il vous faudra également adapter la section uses des unités, elle inclut des modules Lazarus (commençant par "LCL"), en général il devrait suffire de mettre Windows à la place, par contre, c'est pour le .lpr, à renommer en .dpr, que je ne sais pas trop comment ça va se passer. Vous verrez bien, hein, vous êtes des grands garçons !

- Au début des unités vous trouverez {$mode objfpc}{$H+}, à supprimer, sauf pour ceux qui sont sous Lazarus.

- Si vous avez du scintillement, n'oubliez pas DoubleBuffered := True; dans le formCreate, je ne l'ai pas mis car ce n'est pas nécessaire sous Linux.


- Les gens sous Linux-Lazarus seront privilégiés, ils ouvrent le .lpi, ils appuient sur F9 et ils ont une belle image (protocole testé et validé). Ils pourront alors jouer avec les cases à cocher, et pi valà !

Merci de nous tenir au courant.

Et encore deux images RYB, pour la route (dommage qu'on n'ait pas la 'zique) :

[wiwaxia]

Voici une fonction de couleur dépendant d'un paramètre, et conduisant à une répartition équilibrée des couleurs primaires et secondaires, comme le montre la série des palettes suivantes:

La fonction est paire, de période égale à 6 et définie sur [-3 ; +3]: ses variations sont données sur sa partie descendante [1 ; 2] par l'expression:

w = 2 - v + (v - 1)(2 - v)^(1/2)/(1 + h*(v - 1)²)

Deux composantes couleur présentent par rapport à la première un décalage d'un tiers de période, soit 2 unités.

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
 FUNCTION G(h, t: Reel): Reel;             // t varie de -3 … +3
   VAR p, q, r, s, u, v, w: Reel;
   BEGIN
     IF (t>3)  THEN u:= t - 6
               ELSE IF (t<-3) THEN u:= t  + 6
                              ELSE u:= t;
     v:= Abs(u);
     IF  (v<1) THEN w:= 1
               ELSE IF (v>2) THEN w:= 0
                             ELSE BEGIN
                                    p:= v - 1;  q:= Sqrt(2 - v); r:= p * q;
                                    q:= Sqr(p); s:= 1 + (h * q);
                                    q:= r / s;  p:= 2 - v; w:= p + q
                                  END;
     Result:= w
   END;

La matrice de la palette rectangulaire est codée par les instructions suivantes:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 PROCEDURE CalcMat_Im(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST m = 255; Kh = 3.070;
   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; DecR(s, 3);          // (r) varie de 0 à 1 , (s) varie de 0 à 6 , puis de -3 à +3
         w:= G(Kh, s);     Px[1]:= Round(m * w);
         w:= G(Kh, s - 2); Px[2]:= Round(m * w);
         w:= G(Kh, s + 2); Px[3]:= Round(m * w);
         FOR Ym:= 0 TO Ha1 DO Ma[Xm, Ym]:= Px
       END
   END;

celle du cercle chromatique par:

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 CalcMat_Im_C(La, Ha: Z_32; VAR Ma: Tab_Pix);
   CONST I3sPi = 3 / Pi;  Kh = 3.070;
         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);             // t varie de 0 à 2*Pi
                 s:= I3sPi * (t - Pi);           // s varie de -3 à +3
                 w:= G(Kh, s);     Px[1]:= Round(m * w);
                 w:= G(Kh, s - 2); Px[2]:= Round(m * w);
                 w:= G(Kh, s + 2); Px[3]:= Round(m * w)
               END
                         ELSE Px:= Pzero;
             Ma[Xm, Ym]:= Px
           END
       END
   END;

Aucune restriction n'intervient sur le choix des dimensions de l'image.

D'autres fonctions, conduisant à des nuances apparentées, sont bien sûr envisageables.

De tout ce qui précède, tu fais ce que tu veux.

[Jipété]

Voici une fonction de couleur dépendant d'un paramètre, et conduisant à une répartition équilibrée des couleurs primaires et secondaires, comme le montre la série des palettes suivantes:

Oui, c'est très joli et tu as dû beaucoup te prendre la tête, sans compter le camion d'aspirine garé devant la maison, la seule chose qui m'ennuie, c'est qu'en face du rouge je vois un cyan quand j'aurais pu espérer un vert.

Bah, les calculs mathématiques ne sont pas raccord avec les rendus esthétiques, c'est bien connu.
Tiens, regarde, le hasard m'a envoyé ça, tout à l'heure :

De tout ce qui précède, tu fais ce que tu veux.

Merci, cependant, je suggère qu'on laisse un peu faire les autres, et voir ce qu'ils proposent,

Moi je suis en train de ranger la pagaille sur mon bureau et dans les sous-dossiers afférents aux projets et maquettes utilisés pendant ces 55 jours (non, pas de Pékin )

[anapurna]

salut

en face du rouge tu ne peut espérer qu'une couleur composé et pas une couleur primaire
du simple fait que celle-ci comme tu le rappel si bien sont placé à 120° l'une de l'autre sur le cercle

[Jipété]

en face du rouge tu ne peux espérer qu'une couleur composée et pas une couleur primaire
du simple fait que celles-ci comme tu le rappelles si bien sont placées à 120° l'une de l'autre sur le cercle

En mathématiques, oui.

Concernant l'esthétique, il n'y a aucune limitation, aucune restriction, ce qui compte c'est ce qu'on ressent.
Allez, 2 images presque au hasard, issues de ma collec', section "cercles et dégradés RYB" :



Et depuis le début c'est l'esthétique qui m'intéresse. Si j'ai fait un détour par le cercle RGB, c'était pour admirer le paysage, le guide touristique en parlait.
Maintenant, je retourne à mes moutons et à mes préoccupations, comme ce cercle 24 teintes en cours d'étude :


Et, non, il n'y a pas toutes les possibilités 0..255 pour chaque primaire, loin de là, je me suis concentré sur l'esthétique,

[wiwaxia]

La 3me position (à 120° des deux précédentes) est loin de correspondre au bleu pur !

L'écart atteint 40 ° ... et il en est de même pour plusieurs autres couples de couleurs.

[Jipété]

La 3me position (à 120° des deux précédentes) est loin de correspondre au bleu pur !

On est bien d'accord, et c'est ce que j'ai écrit il y a quelques jours (suis-je lu ? Compris ? ) : après avoir bien noté qu'il était impossible d'avoir des couleurs pures d'un bout à l'autre de leur échelle ET que ça soit joli, mon choix est fait, je préfère la beauté chaude des rendus ajustés à la main à la beauté froide des équations.

Ah, on me signale deux défauts (que je n'ai jamais constatés), et un que j'ai trouvé tout seul, alors notez ça et patchez le fichier de l'unité :

Dans ComputeOptimalSizes;, tout en bas :

Code :

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

1
2
3
4
5
  ...
    memo1.Visible   := False;
//    Height := pnl4courbes.Top + pnl4courbes.Height + ckbxFirstLine.Height + 10;
  {$ENDIF}
end;

à commenter sinon impossible de passer en plein écran.

Et Jérôme du forum Lazarus me signale dans la sous-procédure MakeCircle de la procédure ComputeCircle :

Code :

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

1
2
//    for w := -rayon to rayon do begin
      for w := -rayon to rayon-1 do begin

et

Code :

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

1
2
3
4
5
6
//          IF w >= 0 THEN Phase:= (-arctan(h/w)) // on est à* droite dans le cercle
//                    ELSE Phase:= (-arctan(h/w) + Pi); // on y est à* gauche
          IF w > 0 THEN Phase:= (-arctan(h/w)) // on est à droite dans le cercle
          ELSE
          IF w < 0 THEN Phase:= (-arctan(h/w) + Pi) // on y est à gauche
          ELSE {w = 0}  Phase:= (-arctan(h));       // on est au milieu

Et une info Lazarus :

Pour Windows suffit juste de passer le pixelformat des TBitmap à pf32bit ou utiliser des TRGBTriple comme tu l'as suggéré.

[wiwaxia]

On est bien d'accord, et c'est ce que j'ai écrit il y a quelques jours (suis-je lu ? Compris ? ) : après avoir bien noté qu'il était impossible d'avoir des couleurs pures d'un bout à l'autre de leur échelle ET que ça soit joli, mon choix est fait, je préfère la beauté chaude des rendus ajustés à la main à la beauté froide des équations ...

S'il y un domaine justement où les calculs mathématiques apparaissent chaleureux et gratifiants, c'est bien celui de la synthèse des images et des couleurs.

Une solution consiste ici à reprendre les variations de chaque composante couleur sur le domaine [0 ; 6]; le code est plus long, en raison de la perte de symétrie, mais la fin de l'algorithme est étonnamment rapide.
L'intervention sur les parties inclinées d'un terme parabolique Q(h, i, j, s) = h*(s - i)*(j - s) a deux effets bénéfiques:
a) ré-hausser les luminances là où elles sont insuffisantes, notamment au niveau du cyan et de l'orange médian;
b) estomper les raies anormalement brillantes en réduisant (et à la limite en annulant) les ruptures de pente au voisinage de la valeur maximale (1).

(h = 1.000)

Il y a désormais correspondance rigoureuse des couleurs diamétralement opposées: rouge - vert, jaune - violet, bleu - orange.

On retrouve les diverses teintes observées dans le cercle chromatique de Jipété, à l'exception de celle du cyan à son éclat maximal:

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
 CONST  m = 255; Kh = 1.000;
 
 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 PixelRJB(t: Reel): Pixel;               // t varie de 0 … 6
   VAR w: Reel; Test1, Test2: Bool; Px: Pixel;
   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;
     Px[1]:= Round(m * w);
     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
                                                   w:= 0.5 * t;
                                                   IncR(w, Q(Kh/4, 0, 2, t))
                                                 END
                                            ELSE BEGIN
                                                   w:= 4 - t;
                                                   IncR(w, Q(Kh, 3, 4, t))
                                                 END;
     Px[2]:= Round(m * w);
     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;
     Px[3]:= Round(m * w);
     Result:= Px
   END;

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
(*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;

[Jipété]

Salut bonjour,

Ce matin je pensais faire autre chose et voilà que je découvre ton code, avec de jolies images, qui donnent envie de tester, mais…

1-) Concernant les blocs de code :
Mais tu as oublié de nous donner les fonctions Arg2XY et Norme1,

Et une explication, à propos de I3sPi, que j'aurais tendance à traduire (je commence à parler le wwx) inverse de 3 sur Pi, sauf que je lis ça :

Code :

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

CONST I3sPi = 3 / Pi;

Si je n'avais pas vu cette définition, j'en aurais écrit une ainsi :

Code :

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

CONST I3sPi = Pi / 3;

Et dans un cas comme dans l'autre, le "I" dans le nom ne sert à rien à part à embrouiller :
Soit tu as besoin de

Code :

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

CONST 3sPi = 3 / Pi;

soit de

Code :

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

CONST Pis3 = Pi / 3;

Merci d'être clair et précis sur ce coup-là, c'est déjà suffisamment compliqué comme ça.


Une dernière question : pourquoi une constante Kh = 1.000 ? Pourquoi ne pas avoir mis directement dans le code Q(1, 2, 3, t) par ex. (et 0.25 là où tu utilises Kh/4) ?

2-) Concernant le texte et les rendus :
Vu la quantité démente de jaune avec h = 1.000, je vais me rabattre sur h = 0.000 qui, à mes yeux, a une répartition plus harmonieuse.
Mais ce h = ..., où faut-il l'utiliser ? Dans la ligne qui précède les dégradés, là ? :

L'intervention sur les parties inclinées d'un terme parabolique Q(h, i, j, s) = h*(s - i)*(j - s) a deux effets bénéfiques:

Si oui, alors avec h = 0 on gagne Q(0,x,y,z) = 0, pas sûr que ça soit ce que tu avais en tête…
Erreur de nommage dans la seconde partie de l'égalité ?

Quant au mot "parabolique", je n'aurais jamais eu l'idée d'aller le chercher (et d'ailleurs, petit aparté : mis à part l'élévation au carré pour mesurer une surface et au cube pour un volume, je suis parfaitement incapable d'imaginer une quelconque mise en œuvre de formules mathématiques dans la vraie vie : par exemple, autant certains sauront avec précision déterminer l'équation qui va bien pour envoyer dans l'espace encore plus de cochonneries [comme s'il n'y en avait pas déjà suffisamment -- mais ceci est un autre débat] à un endroit précis, autant je suis à des années-lumière de ces manières de penser).


Dans l'attente de tes précisions, je vais commencer la mise en place du reste.

[Jipété]

En attendant tes précisions, parlons d'autre chose, qui concerne la présentation de tes codes et mon immense difficulté à les appréhender.

En fait c'est juste une histoire de typographie et de composition du texte dans la page, terriblement perturbante, qu'on en juge avec ces images réduites, d'abord de ton code brut et sans retouches de la function PixelRJB :

où l'on voit donc 3 grands blocs et un petitou en bas, et si le regard porte au milieu, sur le second bloc, on voit qu'il commence par Px[1]:= Round(m * w);, tout comme le bloc suivant qui commence de la même manière y a que l'index qui change SAUF QUE NON, ce que je viens d'écrire est tout faux, il faut voir ça autrement :



Alors oui, ces grands blancs que j'ai rajoutés sont assez moches, un code plus long s'accommoderait bien de séparations mieux marquées, genre

Code :

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

1
2
3
4
     Px[1]:= Round(m * w);
     ///////////////////////////////////////////////////////////////////
 
     Test1:= ((2<t) AND (t<3));

Ce qui donne ça, quand même plus sympathique pour comprendre instantanément qui fait quoi :


C'est tout.
Ça découle de mes études (toutes personnelles mais oh combien passionnantes et utiles au quotidien) sur la typographie, la mise en page, la lecture du document (au sens large), toutes choses en général inconnues du lecteur mais qui impactent considérablement sa manière d'appréhender un texte et donc, de le comprendre.
Et ce n'est pas parce que c'est du code que ce n'est pas du texte.

EDIT : Et sinon, question code, justement, j'arrive à ça avec la matrice rectangulaire :


J'attends tes réponses à mes questions du post précédent pour voir comment j'intègre ta procédure circulaire.

[wiwaxia]

Re-bonjour,

Je tâche de répondre à toutes tes nombreuses questions.

... 1-) Concernant les blocs de code :[/B]
Mais tu as oublié de nous donner les fonctions Arg2XY et Norme1, ...

Cela a donné lieu à quelques commentaires ou controverses (il y a une dizaine de pages ), et je pensais que tu disposais d'une fonction équivalente.
Il n'y a aucun inconvénient à les reproduire ici:

Code :

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

1
2
3
4
5
 FUNCTION Norme1(u, v: Reel): Reel;
   VAR U2, V2: Reel;
   BEGIN
     U2:= Sqr(u); V2:= Sqr(v); Result:= Sqrt(U2 + V2)
   END;

La fonction Arg2XY(x, y) donne la valeur de l'angle polaire (u_x, OM) en fonction des composantes cartésiennes (x, y) du vecteur (OM), et retourne un résultat compris compris entre 0 et (2*Pi).
Il existe d'ailleurs une autre version (Arg1XY(x, y)) de cette fonction, qui renvoie un résultat allant de (-Pi) à (+Pi); je crois même qu'elle aurait été plus appropriée dans l'un des programmes concernés, mais j'ai eu la flemme de vérifier.

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
 FUNCTION Arg2XY(x, y: Reel): Reel;
   CONST o = 1E-18;
   VAR a, Ux, Uy: Reel;
   BEGIN
     Ux:= Abs(x); Uy:= Abs(y);
     IF ((Ux>o) OR (Uy>o))
       THEN IF Uy>Ux THEN BEGIN
                            a:= Pi / 2; DecR(a, Arctan(x/y));
                            IF y<0 THEN IncR(a, Pi)
                          END
                     ELSE BEGIN
                            a:= Arctan(y/x);
                            IF x<0 THEN IncR(a, Pi)
                                   ELSE IF y<0 THEN IncR(a, 2 * Pi)
                          END
       ELSE a:= 0;
     Arg2XY:= a
   END;

... Et une explication, à propos de I3sPi, que j'aurais tendance à traduire (je commence à parler le wwx) inverse de 3 sur Pi, sauf que je lis ça :

Code :

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

CONST I3sPi = 3 / Pi;

Si je n'avais pas vu cette définition, j'en aurais écrit une ainsi :

Code :

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

CONST I3sPi = Pi / 3;

...

Tu as raison, je suis quelque peu dépassé par les versions successives des programmes, que j'ai été amené à rédiger.
J'ai dû confondre la déclaration

Code :

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

CONST K3sPi = 3 / Pi;  // "Konstante 3 sur Pi"

présente dans une ancienne version, qui se prête facilement à une vérification des calculs, avec une plus récente.

Code :

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

CONST IPis3 = 3 / Pi

Je te signale que la déclaration

Code :

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

CONST 3sPi = 3 / Pi;

n'est pas valide: l'identificateur doit commencer par une lettre - ce serait trop facile !

... Une dernière question : pourquoi une constante Kh = 1.000 ? Pourquoi ne pas avoir mis directement dans le code Q(1, 2, 3, t) par ex. (et 0.25 là où tu utilises Kh/4) ? ...

Parce que cette donnée intervient 6 fois, et qu'elle permet une modification globale, rapide et claire de la distribution des couleurs.
La souplesse du programme, c'est justement de conduire à un ensemble de palettes, et de permettre un choix personnel; il ne s'agit nullement d'un exercice de virtuosité algorithmique, qui serait sans intérêt.
Je posterai les graphes des variations des 3 composantes, qui sont prêts.

... 2-) Concernant le texte et les rendus :
Vu la quantité démente de jaune avec h = 1.000, je vais me rabattre sur h = 0.000 qui, à mes yeux, a une répartition plus harmonieuse.
Mais ce h = ..., où faut-il l'utiliser ? Dans la ligne qui précède les dégradés, là ? :

L'extension du jaune est liée à celle de l'orange; on peut y remédier partiellement par une correction locale, qui est envisageable.
Ton choix me surprend: la première palette (h = 0) est pour moi la plus décevante; n'es-tu pas choqué par la présence des deux raies brillantes (jaune et verte), et celle du grisé sombre situé juste eu peu plus loin ? Le choix m'aurait paru possible au-delà de 0.7 seulement ... De plus les teintes de ton cercle chromatique sont très proches de celle de la dernière palette (h = 1): tes préférences ne sont-elles pas contradictoires ?

... Quant au mot "parabolique", je n'aurais jamais eu l'idée d'aller le chercher (et d'ailleurs, petit aparté ...

Dans un repère cartésien (xOy), toute parabole d'axe vertical admet pour équation une expression de la forme:

y = a*x² + b*x + c .

Par extension, on appelle parabolique toute fonction représentée par un trinôme du second degré.
Le polynôme proposé appartient à cette catégorie:

Q(h, i, j, s) = h*(s - i)*(j - s) = h*(-s² + (i + j)*s - i*j) = -h*s² + h*(i + j)*s - h*i*j

C'est tout simplement le polynôme qui s'annule pour (s=i) ou (s=j), et présente une valeur maximale au milieu de l'intervalle (s = (i + j)/2):
Q(h, i, j, (i+j)/2) = h*(j - i)²/4 .
Il s'agit de la correction typique et simple que l'on peut introduire dans une formule, pour améliorer le résultat.

Code :

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

1
2
3
4
5
6
 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;

[Jipété]

Cela a donné lieu à quelques commentaires ou controverses (il y a une dizaine de pages ), et je pensais que tu disposais d'une fonction équivalente.

J'en ai une, mais elle accepte plus de paramètres et se nomme norme1_2.

Je te signale que la déclaration

Code :

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

CONST 3sPi = 3 / Pi;

n'est pas valide: l'identificateur doit commencer par une lettre - ce serait trop facile !

Exact, mais au saut du lit ceci peut expliquer cela,

Parce que cette donnée intervient 6 fois, et qu'elle permet une modification globale, rapide et claire de la distribution des couleurs.

Il me semblait juste 4 et surtout, je n'avais pas fait le rapprochement entre h d'un côté et Kh de l'autre.

Ton choix me surprend: la première palette (h = 0) est pour moi la plus décevante; n'es-tu pas choqué par la présence des deux raies brillantes (jaune et verte), et celle du grisé sombre situé juste eu peu plus loin ?

Les raies brillantes on a dit il y a peu qu'elles étaient inévitables, donc je "prends sur moi", par contre la partie grisée je ne l'ai pas vue tout de suite, du coup je passe à 0.4


À moi.
Voilà la fonction pour le cercle dans toute sa splendeur,


Au premier coup d'œil on voit tout de suite que le centre du cercle s'installe à la moitié du rayon, va savoir pourquoi…
Et comme je suis curieux, j'ai tenté à l'arrache Xc:= La1;// / 2; mais si je pars alors du centre, je ne fais pas tout le tour du cercle, idem en supprimant l'autre division par 2.

Et comme je n'ai plus les yeux en face des trous, je te laisse réfléchir à ça.

[wiwaxia]

En attendant tes précisions, parlons d'autre chose, qui concerne la présentation de tes codes et mon immense difficulté à les appréhender.

En fait c'est juste une histoire de typographie et de composition du texte dans la page, terriblement perturbante, qu'on en juge avec ces images réduites, d'abord de ton code brut et sans retouches de la function PixelRJB :
... / ...
C'est tout.
Ça découle de mes études (toutes personnelles mais oh combien passionnantes et utiles au quotidien) sur la typographie, la mise en page, la lecture du document (au sens large), toutes choses en général inconnues du lecteur mais qui impactent considérablement sa manière d'appréhender un texte et donc, de le comprendre.
Et ce n'est pas parce que c'est du code que ce n'est pas du texte ...

Tu as tout à fait raison. J'étais pressé d'en finir, et soucieux de tout voir afin de ne pas commettre de bourde (six booléens à coder, et six intervalles !).
D'où la présence d'un bloc comportant manifestement trois parties indépendantes, et débordant de la page d'écran: façon de procéder bien peu conforme à l'idéal pascalien. Je mettrai cela en ordre dès que possible.

... Les raies brillantes on a dit il y a peu qu'elles étaient inévitables, donc je "prends sur moi", par contre la partie grisée je ne l'ai pas vue tout de suite, du coup je passe à 0.4 ...

Là, tu exagères !
Les raies brillantes sont tout à fait évitables,
leur cause est avérée (la discontinuité de pente des fonctions de couleur),
on en parlé depuis le début de ces échanges, et
j'ai donné trois algorithmes permettant de les réduire images à l'appui:

1) Le plus récent, le plus simple et le plus efficace
#285

2) #276 Fonctions paramétrables se rapprochant de la fonction linéaire par morceaux (code cependant un peu lourd).

3) #230 Palettes données par les fonctions F1, F2, F3, F4, et comparées à la fonction LM.

4) #113 Premières évocations des raies brillantes ...

Je présenterai dans le détail les fonctions actuellement en cause, et conduisant à la palette RJB.
Les palettes ont été postées sur #291 la nuit dernière, soit 5 messages plus tôt ! Pour parler avec toi d'un sujet donné, il faut s'accrocher ferme !

[Jipété]

Pour parler avec toi d'un sujet donné, il faut s'accrocher ferme !

Parce que ça touche à tout un tas d'aspects.

+++
Et pour le rendu du cercle, pas d'idée ?

[Jipété]

1) Le plus récent, le plus simple et le plus efficace
#285

Euh non, le plus récent c'est celui-ci :

Les palettes ont été postées sur #291 la nuit dernière

Pratiquement le même que l'autre, d'ailleurs, juste la gestion de la manière de récupérer les données qui changent.

Donc ces deux algos incorporent une manière bizarre de gérer un truc, qui fait un gros changement quand j'inverse pour le remettre d'équerre :

Code :

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

IF (Xc<Yc) THEN Rmax:= Xc ELSE Rmax:= Yc;

Dit en français : si Xc est plus petit que Yc alors la valeur max est Xc sinon c'est Yc. Et ça ne choque personne ?
Donc si j'inverse avec IF (Xc>Yc) THEN Rmax:= Xc ELSE Rmax:= Yc; et que ce qu'on lit tombe maintenant sous le sens, alors je parcours tout le cercle, c'est mieux, et les teintes sont là :


comparé au morceau minable de ce matin, bien que les teintes soient là également :


Mais dans un cas comme dans l'autre, je ne comprends pas pourquoi le centre du cercle dessiné s'installe à la moitié du rayon,

Alors je supprime les divisions par 2 pour Xc et Yc au début de la proc et du coup j'arrive à ça :


On dirait que le parcours est correct, mais c'est le rendu des teintes qui est en vrac.
Ça me dépasse…

[wiwaxia]

W: 1) Le plus récent, le plus simple et le plus efficace
#285

Euh non, le plus récent c'est celui-ci :

W: Les palettes ont été postées sur #291 la nuit dernière

Je ne parlais pas du nouveau type de palette (RJB), que je traitais pour la première fois d'une manière complète, et que n'ai pas fini de présenter.

... Pratiquement le même que l'autre, d'ailleurs, juste la gestion de la manière de récupérer les données qui changent ...

Les algorithmes sont apparentés, mais il intervient dans ce cas trois fonctions couleur au lieu d'une seule.

... Donc ces deux algos incorporent une manière bizarre de gérer un truc, qui fait un gros changement quand j'inverse pour le remettre d'équerre :

Code :

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

IF (Xc<Yc) THEN Rmax:= Xc ELSE Rmax:= Yc;

Dit en français : si Xc est plus petit que Yc alors la valeur max est Xc sinon c'est Yc. Et ça ne choque personne ?

(Rmax) représente le rayon du cercle chromatique dans l'image rectangulaire, et il est égal à la plus petite des coordonnées du centre afin qu'il n'y ait pas de débordement.
Exemple: La = 500; Ha = 200; d'où:
Xc = (La - 1)/2 = 249.5 ; Yc = (Ha - 1)/2 = 99.5 ; Rmax = Min(Xc, Yc) = 99.5 .

... Donc si j'inverse avec IF (Xc>Yc) THEN Rmax:= Xc ELSE Rmax:= Yc; ...
Mais dans un cas comme dans l'autre, je ne comprends pas pourquoi le centre du cercle dessiné s'installe à la moitié du rayon,

Alors je supprime les divisions par 2 pour Xc et Yc au début de la proc et du coup j'arrive à ça :
...
On dirait que le parcours est correct, mais c'est le rendu des teintes qui est en vrac.
Ça me dépasse…

Si tu improvises n'importe quoi, le code devient incohérent, et il n'y a plus de discussion possible.

L'inversion de l'instruction conduirait au résultat suivant: Rmax = Max(Xc, Yc) = Max(249.5, 99.5) = 249.5 .

[Jipété]

Bonjour,

(Rmax) représente le rayon du […]

Oui, ça je l'avais compris, mais quelle idée aussi de nommer cette variable Rmax alors qu'elle cherche un min !

Bref, je l'ai renommée et j'ai modifié la ligne ainsi, c'est quand même plus cool : rayonC := min(Xc, Yc);, rayon"C" parce que j'ai déjà un rayon tout court globalement défini dans le prog, qui commence à ressembler à ça :

Si tu improvises n'importe quoi, le code devient incohérent, et il n'y a plus de discussion possible.

Quand je suis face à des noms qui ne représentent pas ce qu'ils font, je considère que je baigne déjà dans le n'importe quoi, alors un peu plus un peu moins, exemple avec ta fonction Norme1, très perturbante dans le sens où j'en ai déjà une que j'ai appelée "Normalize" (qui "clampe" à min 0 max 255 les datas qu'on lui passe), et que la tienne renvoie en fait la racine carrée de la somme des deux variables passées et élevées au carré, l'hypoténuse, quoi ! Alors Norme1, excuse-moi mais celui qui lit ça est passablement dérouté.

Bref, j'ai tout remis comme à l'origine (sauf le renommage et certaines simplifications), et j'ai activé mon système d'enregistrement du fichier, exécution et là, stupéfaction, ton bitmap est rond et beau (mis à part une inversion haut-bas sans doute liée à l'opposition Windows-Linux concernant la manière de gérer les bitmaps) :


Conclusion, souci lié à mon système d'affichage qui serait à repenser, et je me retrouve avec cette énorme masse jaune, donc Kh à 0.0 (qui ne la fait pas diminuer beaucoup).

Me demande s'il faut que je me prenne la tête avec CalcMat_Im_C puisque j'en ai une autre qui fait bien le boulot, avec dégradés blanc->couleur->noir et redimensionnement automatique, et là on a Kh à 0.4 (image réduite au tiers) :