Discussion :

[Jipété]

-- snip --

OK, merci pour tout ça, que je vais étudier, ça va me changer les idées de ce que je vis, y a des fois c'est un cauchemar, qu'on en juge avec le passage en niveaux de gris pour lequel je me suis simplement inspiré des formules de The Gimp, trouvées dans l'aide :

Lightness clarté,
The graylevel will be calculated as
Lightness = ½ × (max(R,G,B) + min(R,G,B))

Luminosity luminosité
The graylevel will be calculated as
Luminosity = 0.21 × R + 0.72 × G + 0.07 × B

Average moyenne
The graylevel will be calculated as
Average Brightness = (R + G + B) ÷ 3

J'ai donc mis ça en œuvre ainsi :

Code :

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

1
2
3
4
5
6
7
    ColorToRGB(aColor, r,b,g);
    case rdgpGris.ItemIndex of
      0: aByte := round( (max( max(r,g),b )+min( min(r,g),b ))*0.5 );// Lightness
      1: aByte := round( (r*0.21)+(g*0.72)+(b*0.07) );// Luminosity
      2: aByte := round( (r+g+b)*0.33333333 );// Average
    end;
    Result := RGBtoColor(aByte,aByte,aByte);

j'exécute mon programme (en haut du gif), j'en profite pour faire une copie d'écran dans The Gimp (en bas) des 24 bandes colorées (les couleurs ont changé, ben oui, les valeurs en fin de post), je convertis l'image dans l'outil avec le code (options à droite) et dans The Gimp avec le menu "Couleurs/Désaturer", et on pleure à chaudes larmes quand arrive l'option "Luminosité" :



Ce qui est curieux, c'est qu'une analyse au color picker pour le mode "Luminosité" montre, pour la première bande, 66 66 66 pour The Gimp (une calculette affiche 65,01) et 60 60 60 dans mon outil.
S'il y avait une blague dans mon outil, ça impacterait les autres options, et ce n'est pas le cas, le gif le prouve.
Alors ?
Alors je ne sais pas...

Les 24 nouvelles couleurs :

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
791789
996853
610550
552183
428281
368890
375039
379376
381665
1433800
1893287
4644229
4377929
8367397
11440659
13332501
14571031
13583935
14104415
14361724
12130449
9573800
7606980
3410146

[wiwaxia]

Ce qui est curieux, c'est qu'une analyse au color picker pour le mode "Luminosité" montre, pour la première bande, 66 66 66 pour The Gimp (une calculette affiche 65,01) et 60 60 60 dans mon outil.
S'il y avait une blague dans mon outil, ça impacterait les autres options, et ce n'est pas le cas, le gif le prouve.

Quelles sont les valeurs initiales des indices (r, v, b) ?

[Jipété]

Quelles sont les valeurs initiales des indices (r, v, b) ?

La couleur de la bande, éclatée ainsi :

J'ai donc mis ça en œuvre ainsi :

Code :

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

1
2
3
4
5
6
7
8
    ColorToRGB(aColor, r,b,g);  // réponse à wwx
 
    case rdgpGris.ItemIndex of
      0: aByte := round( (max( max(r,g),b )+min( min(r,g),b ))*0.5 );// Lightness
      1: aByte := round( (r*0.21)+(g*0.72)+(b*0.07) );// Luminosity
      2: aByte := round( (r+g+b)*0.33333333 );// Average
    end;
    Result := RGBtoColor(aByte,aByte,aByte);

À propos de ton code, il manque encore deux bricolettes :

Code :

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

1
2
 Error: Identifier not found "GraphBmp"
 Error: Identifier not found "Creation_F"

[wiwaxia]

Code :

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

1
2
3
4
5
6
7
    ColorToRGB(aColor, r,b,g);
    case rdgpGris.ItemIndex of
      0: aByte := round( (max( max(r,g),b )+min( min(r,g),b ))*0.5 );// Lightness
      1: aByte := round( (r*0.21)+(g*0.72)+(b*0.07) );// Luminosity
      2: aByte := round( (r+g+b)*0.33333333 );// Average
    end;
    Result := RGBtoColor(aByte,aByte,aByte);

S'agit-il bien d'une fonction ? Ne faudrait-il pas une paire de délimiteurs de blocs (BEGIN / END) ? Je dis peut-être une bêtise, mais je comprends mal ce que tu donnes; j'aurais vu:

Code :

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

1
2
3
4
5
6
7
8
9
FUNCTION ColorToRGB(aColor, r,b,g): Byte;
BEGIN
    case rdgpGris.ItemIndex of
      0: aByte := round( (max( max(r,g),b )+min( min(r,g),b ))*0.5 );// Lightness
      1: aByte := round( (r*0.21)+(g*0.72)+(b*0.07) );// Luminosity
      2: aByte := round( (r+g+b)*0.33333333 );// Average
    end;
Result := RGBtoColor(aByte,aByte,aByte)
END;

D'autre part, tu ne donnes pas les valeurs numériques des indices (r, v, b) conduisant aux trois sortes de résultats.

Ce qui est curieux, c'est qu'une analyse au color picker pour le mode "Luminosité" montre, pour la première bande, 66 66 66 pour The Gimp (une calculette affiche 65,01) et 60 60 60 dans mon outil.

De plus, l'intrication des fonctions Min(.), Max(.), n'est pas une bonne option.
Le recours à la fonction suivante (que tu nommeras comme tu veux) serait beaucoup plus rapide:

Code :

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

1
2
3
4
5
6
7
FUNCTION Lum0(r, v, b: Byte): Byte;
  VAR Max, Min, s: Word;
  BEGIN
    IF (r>v) THEN Max:= r ELSE Max:= v; IF (Max<b) THEN Max:= b;
    IF (r<v) THEN Min:= r ELSE Min:= v; IF (Min>b) THEN Min:= b;
    s:= Min + Max;                      Result:= Round(0.5 * s)
END;

Je crois percevoir d'odieux ricanements au sujet de

Code :

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

(r+g+b)

et même de

Code :

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

aByte := round( (Max + Min)*0.5 );

Je me suis déjà fait avoir, aussi - c'est pourquoi je suis devenu méfiant ...
Mais peut-être ton logiciel incorpore-t-il un ange gardien virtuel ?

[Jipété]

S'agit-il bien d'une fonction ? Ne faudrait-il pas une paire de délimiteurs de blocs (BEGIN / END) ?

Pendant que tu écrivais ta réponse (et, oui, c'est une fonction, je n'ai posté ici que la partie utile), je modifiais mes calculs ainsi, m'affranchissant des débordements de byte (calcul est un integer) :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
    jpColorToRGB(aColor, r,b,g);
    case rdgpGris.ItemIndex of
      0: calcul := round( (max(max(r,g),b)+min(min(r,g),b))*0.5 );// Lightness
      1: calcul := round( (r*0.21)+(g*0.72)+(b*0.07) );// Luminosity
      2: calcul := round( (r+g+b)*0.33333333 );// Average
    end;
    if calcul > 255 then aByte := 255 else
    if calcul < 0 then aByte := 0 else
    aByte := byte(calcul);
    Result := jpRGBtoColor(aByte,aByte,aByte);

Mais j'ai fini par trouver !
Cochonnerie de cerveau qui traduit dans notre dos les choses qui ne lui plaisent pas (j'ai laissé la faute ci-dessus exprès, ainsi que dans le post où je présente ce problème [qui n'en est pas un, in fine]), et tout le monde s'est fait avoir, et c'est d'autant plus vicieux que ça n'impactait pas les choix 0 et 2 :

Code pascal :

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

1
2
//    jpColorToRGB(aColor, r,b,g); // aaaaaargh ! Damned !
      jpColorToRGB(aColor, r,g,b); // +1 !

Ouf !

De plus, l'intrication des fonctions Min(.), Max(.), n'est pas une bonne option.

Et pourquoi donc ?

Le recours à la fonction suivante (que tu nommeras comme tu veux) serait beaucoup plus rapide:

Et pourquoi donc ?
Si je la présente autrement :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
12
FUNCTION Lum0(r, v, b: Byte): Byte;
  VAR Max, Min, s: Word;
  BEGIN
    IF (r>v) THEN Max:= r ELSE Max:= v; 
    IF (Max<b) THEN Max:= b;
 
    IF (r<v) THEN Min:= r ELSE Min:= v; 
    IF (Min>b) THEN Min:= b;
 
    s:= Min + Max;                      
    Result:= Round(0.5 * s)
END;

on voit bien qu'on a 4 tests suivis d'affectations, ce qui est exactement ce qui se passe dans les fonctions FreePascal (en voilà une, l'autre c'est pareil au sens de la comparaison près :

Code pascal :

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

1
2
3
4
function Max(a, b: VARTYPE): VARTYPE; inline;
begin
  if a > b then Result := a else Result := b;
end;

J'ai écrit VARTYPE car il y en a une tripotée, de l'int64 à l'extended -- j'allais pas tout recopier ni en choisir une)

Àmha, au fin fond des instructions machine générées par le compilo, on devrait lire les mêmes choses, non ?

[wiwaxia]

Citation Envoyé par wiwaxia Voir le message
De plus, l'intrication des fonctions Min(.), Max(.), n'est pas une bonne option.
Et pourquoi donc ?

Citation Envoyé par wiwaxia Voir le message
Le recours à la fonction suivante (que tu nommeras comme tu veux) serait beaucoup plus rapide:
Et pourquoi donc ?

On l'a testé il y a un an ou deux à propos d'un autre sujet: l'imbrication des fonctions Max(x, y) et Min(x, y) présente un temps d'exécution plus long que les instructions équivalentes directement écrites dans la procédure.
C'est un exercice purement formel, séduisant par son aspect, mais dont l'efficacité n'est pas forcément optimale.

[Jipété]

On l'a testé il y a un an ou deux à propos d'un autre sujet: l'imbrication des fonctions Max(x, y) et Min(x, y) présente un temps d'exécution plus long que les instructions équivalentes directement écrites dans la procédure.
C'est un exercice purement formel, séduisant par son aspect, mais dont l'efficacité n'est pas forcément optimale.

Tiens, j'ai retrouvé ça, si tu veux t'amuser à tester :

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
function MinValue(const Data: array of double): double;
var
  I: Integer;
begin
  Result := Data[Low(Data)];
  For I := Succ(Low(Data)) To High(Data) Do
    If Data[I] < Result Then Result := Data[I];
end;
 
function MaxValue(const Data: array of double): double;
var
  I: Integer;
begin
  Result := Data[Low(Data)];
  For I := Succ(Low(Data)) To High(Data) Do
    If Data[I] > Result Then Result := Data[I];
end;

C'est sympa, ça peut accepter plein de valeurs, juste que l'utilisation surprend un peu, il faut parenthèses et crochets, comme ça :
calcul := round( ( maxvalue([r,g,b]) + minvalue([r,g,b]) ) *0.5 );// Lightness. J'avoue bien honnêtement que j'ai une flemme énooooorme à monter un projet de test pour comparer les durées d'exécution, par contre si quelqu'un sait par quoi remplacer "double", genre

Code pascal :

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

1
2
3
VARTYPE = integer; // ou n'importe quoi d'autre de valide, puis
function MaxValue(const Data: array of VARTYPE): VARTYPE; 
// et pareil pour MinValue

ça éviterait 4 copier/coller. Bon, ça serait mieux dans le forum Lazarus,

Et sinon, vous avez vu les derniers chiffres pour la palette de 24 TColor, alors, cette palette recopiée à l'identique sans autre forme de procès dans le projet en attente et hop !, bim bam boum, ça déchire sa race je trouve :

Non ?


EDIT : ah, j'oubliais :


wwx, tu m'oublieras pas, hein,

À propos de ton code, il manque encore deux bricolettes :

Code pascal :

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

1
2
 Error: Identifier not found "GraphBmp"
 Error: Identifier not found "Creation_F"

[Jipété]

Va falloir que je revoie la palette un chouchouille :



avec un cercle de 411 px de diamètre, le défaut réapparaît au niveau du raccord des rouges, et si je mets la première et la dernière zone au même rouge, ça va faire une zone énorme.
Je ne sais pas trop comment je vais gérer tout ça, esthétiquement parlant.

Bah, la nuit porte conseil,

[wiwaxia]

Tiens, j'ai retrouvé ça, si tu veux t'amuser à tester :
... / ... C'est sympa, ça peut accepter plein de valeurs, juste que l'utilisation surprend un peu, il faut parenthèses et crochets, comme ça :
calcul := round( ( maxvalue([r,g,b]) + minvalue([r,g,b]) ) *0.5 );// Lightness. J'avoue bien honnêtement que j'ai une flemme énooooorme à monter un projet de test pour comparer les durées d'exécution, par contre si quelqu'un sait par quoi remplacer "double", genre

Code pascal :

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

1
2
3
VARTYPE = integer; // ou n'importe quoi d'autre de valide, puis
function MaxValue(const Data: array of VARTYPE): VARTYPE; 
// et pareil pour MinValue

ça éviterait 4 copier/coller. Bon, ça serait mieux dans le forum Lazarus,

Et sinon, vous avez vu les derniers chiffres pour la palette de 24 TColor, alors, cette palette recopiée à l'identique sans autre forme de procès dans le projet en attente et hop !, bim bam boum, ça déchire sa race je trouve :
... / ... Non ?

Je dispose d'un programme de chronométrage pour la comparaison des algorithmes, prêt à l'emploi.

Le code proposé est intéressant, et je regarderai au plus tôt si Virtual Pascal l'accepte. Mais je suis franchement à la bourre, car l'ordi doit rejoindre sa valise demain matin au plus tard.

... EDIT : ah, j'oubliais :
... / ...
wwx, tu m'oublieras pas, hein,

Si tu y tiens vraiment, pas de problème:

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
 
 PROCEDURE GraphBmp(Code_Cf: Z_32);
   BEGIN
     Saisie_Dim_BMP(2, 4, Larg_Image, Haut_Image, Prod_LaHa);
     InitMatrIm(4, Code_Cf, Matr_Image);
     CalcTaille(Larg_Image, Haut_Image, T_Image, T_Fichier);
     Init_Entete(En_Tete);
   END;
 
 PROCEDURE Creation_F(La, Ha: Z_32);
   CONST C1 = 71; L1 = 9; Lim = T_Entete - 1;
   VAR Delta, n, Zero: Byte; k, x, y: Z_32;
   BEGIN
     Aff_NomF(Nom_F); Assign(Fichier, Nom_F); Rewrite(Fichier);
     FOR k:= 0 TO Lim DO Write(Fichier, En_Tete[k]);
     k:= Lim;         E(0008);                Compteur(C1, L1-1, -k);
     E(0012);         Delta:= La MOD 4;       Zero:= 0;
     FOR y:= 0 TO (Ha - 1) DO
       BEGIN
         FOR x:= 0 TO (La -1) DO
           FOR n:= 3 DOWNTO 1 DO BEGIN            // Inversion (RvB)/(BvR)
                                   Inc(k);
                                   Write(Fichier, Matr_Image[x, y][n]);
                                   Compteur(C1, L1, k)
                                 END;
         IF Delta>0 THEN FOR n:= 1 TO Delta DO BEGIN
                                                 Inc(k); Write(Fichier, Zero);
                                                 Compteur(C1, L1, k)
                                               END
       END;
     Close(Fichier);       Compteur(C1, L1, -k);
     E(0008);              Wt(4, L1, 'Rang du dernier octet:');
     Compteur(39, L1, -k); E(0014); Wt(C1-1, L1+2, 'Û  FIN  Û')
   END;

Je n'ai pas le temps d'entrer dans les détails.

Si tu y tiens vraiment, je peux te fournir le code complet, initialement conçu pour le Turbo Pascal.

# PS:

Va falloir que je revoie la palette un chouchouille :



avec un cercle de 411 px de diamètre, le défaut réapparaît au niveau du raccord des rouges, et si je mets la première et la dernière zone au même rouge, ça va faire une zone énorme.
Je ne sais pas trop comment je vais gérer tout ça, esthétiquement parlant.

Bah, la nuit porte conseil,

Superbe, la palette, sauf que tu n'a pas mis le bon algorithme
La double boucle

Code :

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

1
2
FOR x:= X1 TO X2
  FOR y:= Y1 TO Y2

n'est pas convenablement bornée.

[wiwaxia]

J'ai injecté ta nouvelle constante dans le programme précédent:

Code :

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

1
2
3
4
5
         Liste24C_Lint_Jpt01: ARRAY[0..Dim_Pal - 1] OF Z_32 =
           ( 791789,   996853,   610550,   552183,   428281,   368890,
             375039,   379376,   381665,  1433800,  1893287,  4644229,
            4377929,  8367397, 11440659, 13332501, 14571031, 13583935,
           14104415, 14361724, 12130449,  9573800,  7606980,  3410146);

La continuité est effectivement respectée au niveau du rouge:

[Jipété]

Le code proposé est intéressant, et je regarderai au plus tôt si Virtual Pascal l'accepte. Mais je suis franchement à la bourre, car l'ordi doit rejoindre sa valise demain matin au plus tard.

Oublie tout et bonnes vacances,

Superbe, la palette, sauf que tu n'a pas mis le bon algorithme
La double boucle

Code :

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

1
2
FOR x:= X1 TO X2
  FOR y:= Y1 TO Y2

n'est pas convenablement bornée.

Rien compris : je n'ai pas posté d'algo depuis longtemps...

EDIT : je viens de boucler à l'instant une nouvelle manière de faire, qui produit des merveilles comme ça :



On en parle à ton retour...

[wiwaxia]

W:Superbe, la palette, sauf que tu n'a pas mis le bon algorithme
La double boucle

Code :

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

1
2
FOR x:= X1 TO X2
  FOR y:= Y1 TO Y2

n'est pas convenablement bornée.
Rien compris : je n'ai pas posté d'algo depuis longtemps...

Non, mais cela se devine à l'examen de l'image.

# Merci pour le rappel opportun des fonctions High et Low, dont je n'avais qu'un très vague souvenir, et n'utilisais jamais.

Tiens, j'ai retrouvé ça, si tu veux t'amuser à tester :

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
function MinValue(const Data: array of double): double;
var
  I: Integer;
begin
  Result := Data[Low(Data)];
  For I := Succ(Low(Data)) To High(Data) Do
    If Data[I] < Result Then Result := Data[I];
end;
 
function MaxValue(const Data: array of double): double;
var
  I: Integer;
begin
  Result := Data[Low(Data)];
  For I := Succ(Low(Data)) To High(Data) Do
    If Data[I] > Result Then Result := Data[I];
end;

Cela peut s'incorporer à du code ordinaire:

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
 PROGRAM FOR_Low_High;
 
 USES Crt, E_Texte;
 
 CONST N1 = -3; N2 = N1 + 10;
 
 TYPE Tab10W = ARRAY[N1..N2] OF Word;
 
 CONST Liste: Tab10W = (1772, 6685, 1598, 6511, 1424,
                        6337, 1250, 6163, 1076, 5989, 902);
 
 FUNCTION Val_Max(Data: Tab10W): Word;
   VAR i: Z_08; w: Word;
   BEGIN
     w:= Data[Low(Data)];
     FOR i:= Succ(Low(Data)) TO High(Data) DO
       IF (w<Data[I]) THEN w:= Data[I];
     Result:= w
   END;
 
 FUNCTION Val_Min(Data: Tab10W): Word;
   VAR i: Z_08; w: Word;
   BEGIN
     w:= Data[Low(Data)];
     FOR i:= Succ(Low(Data)) TO High(Data) DO
       IF (w>Data[I]) THEN w:= Data[I];
     Result:= w
   END;
 
 PROCEDURE P1;
   CONST C1 = 10; L1 = 10; o = 6;
   VAR i: Z_08; k: Word;
   BEGIN
     E(1015); Wt(2, L1 - 6, 'Rang (i)  = ');
     FOR i:= Low(Liste) TO High(Liste) DO
       BEGIN
         IF ((i=Low(Liste)) OR (i=High(Liste))) THEN E(0012)
                                                ELSE E(0014);
         Write(i:o)
       END;
     E(0015); Wt(2, L1 - 4, 'Valeur[i] = ');
     E(0010); FOR i:= Low(Liste) TO High(Liste) DO Write(Liste[i]:o);
 
     E(0015); Wt(C1, L1 - 1, 'Low(Liste)  = '); E(0012); Write(Low(Liste):o);
     E(0015); Wt(C1, L1 + 1, 'High(Liste) = '); E(0012); Write(High(Liste):o);
 
     k:= Val_Min(Liste); E(0015);
     Wt(C1, L1 + 4, 'Val Minimale: Min = '); E(0012); Write(k:o);
     k:= Val_Max(Liste); E(0015);
     Wt(C1, L1 + 6, 'Val Maximale: Max = '); E(0012); Write(k:o); A_
   END;
 
 BEGIN
   P1
 END.

[wiwaxia]

Oublie tout et bonnes vacances ...

Merci, je fais pour le mieux ... Heureusement le jardinage et la programmation sont là pour la détente.

... EDIT : je viens de boucler à l'instant une nouvelle manière de faire, qui produit des merveilles comme ça :

On en parle à ton retour...

Tu as probablement eu recours à une fonction continue linéaire par morceaux, et la rupture de pente au point de raccordement est à l'origine du cercle brillant observé sur l'image, à la limite des deux zones.
L'oeil est non seulement très sensible aux écarts de teintes, mais aussi à leur taux de variation en fonction de leur position.

J'ai repris rapidos la programmation de la palette à partie de la même séquence de 24 couleurs, en y intégrant l'évolution transversale vers le blanc ou le noir. L'intervention d'une loi parabolique sur la moitié du domaine ([0 ; 1/2] ou [1/2 ; 1] selon les cas) permet d'assurer, en plus de la continuité de la fonction, celle de sa dérivée première; on observe qu'elle s'accompagne de la disparition de la trace lumineuse (rectiligne ou circulaire).
Comparer les images obtenues dans les cas:
a) d'une fonction linéaire présentant une discontinuité de pente,
b) d'une fonction continument dérivable
pour 1°) la palette rectangulaire:

_

et 2°) le cercle chromatique:

_

Les mêmes fonctions interviennent dans les deux sortes de palettes.

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
 FUNCTION FPx2(x: Reel; Pref_: Pixel): Pixel;     // Evolution vers le noir
   VAR k: Byte; h, H4, p, q, X1, X2, z: Reel; Px: Pixel;
   BEGIN
     FOR k:= 1 TO 3 DO
       BEGIN
         h:= Pref_[k] / Im; X1:= 1 - x;
         q:= 2 * h;         z:= q * X1;
         IF (h>0.5) THEN BEGIN
                           X2:= 2 * x; q:= X2 - 1; p:= X1 * q;
                           H4:= 4 * h; q:= H4 - 2; IncR(z, p * q)
                         END;
         Px[k]:= Round(Im * z)
       END;
     Result:= Px
   END;

 FUNCTION FPx1(x: Reel; Pref_: Pixel): Pixel;     // Evolution vers le blanc
   VAR k: Byte; h, H2, p, q, X2, z: Reel; Px: Pixel;
   BEGIN
     FOR k:= 1 TO 3 DO
       BEGIN
         h:= Pref_[k] / Im; X2:= 2 * x;
         q:= h - 1;         p:= q * X2; z:= 1 + p;
         IF (h<0.5) THEN BEGIN
                           q:= X2 - 1; p:= X2 * q;
                           H2:= 2 * h; q:= 1 - H2; IncR(z, p * q)
                         END;
         Px[k]:= Round(Im * z)
       END;
     Result:= Px
   END;

Pour revenir aux fonctions linéaires les plus simples, il suffit de neutraliser les blocs d'instructions marqués en rouge, et qui introduisent un monôme du second degré de la forme K1*(2*x)*(2*x - 1) ou K2*(1 - x)*(2*x - 1) .
Cela ne doit pas poser de difficultés.

Finalement, je n'ai pas tout oublié.

[Jipété]

Et bonjour,

Je vois que tu ne lâches pas l'affaire, c'est beau la passion

Tu as probablement eu recours à une fonction continue linéaire par morceaux, et la rupture de pente au point de raccordement est à l'origine du cercle brillant observé sur l'image, à la limite des deux zones.

une fonction continue linéaire par morceaux
Qu'est-ce que j'en sais, moi ? J'ai utilisé une boîte noire à qui je passe la couleur de début, celle du milieu et celle de fin et ça me sort ce qu'il me faut.
Quand j'examine l'intérieur de la fonction, je trouve ça :

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
  for i := 0 to High(aColors) do
  begin
    if aVertical then
    begin
      Vertex[i].X     := X[Odd(i)];
      Vertex[i].Y     := Round(aRect.Top  + Step *i);
    end else
    begin
      Vertex[i].X     := Round(aRect.Left + Step *i);
      Vertex[i].Y     := X[Odd(i)];
    end;
    Vertex[i].Red   := GetRValue(aColors[i]) *$100;
    Vertex[i].Green := GetGValue(aColors[i]) *$100;
    Vertex[i].Blue  := GetBValue(aColors[i]) *$100;
  end;

et je n'y vois pas de rupture, on va de 0 à High(aColors).
Quelque part c'est un peu comme le dégradé classique RGB qui fait varier les couleurs de 0 à 255 et on a bien vu il y a qq années que ça générait des zones de surbrillances, alors que mathématiquement c'est tout ce qu'il y a de plus linéaire.
Je suis parti de ça, il y a trois ans :

ça se trouve là (et tout à la fin je lui ai corrigé une typo, au monsieur, -- il faudrait refaire les indications de l'axe horizontal)

Le cercle brillant au milieu de la boule de billard, on en a déjà parlé, récemment et il y a longtemps ; maintenant, si tu penses qu'un traficotage parabolique peut arranger le rendu, allons-y, soyons fous, ce n'est pas encore les grandes vacances (mais dépêchons-nous, elles arrivent à grands pas )

D'autant plus que si je rajoute du flou sur ton rendu, ça fait disparaître ce centre blanc en forme de super-nova en train d'exploser :

Cependant, un examen attentif me montre, dans les rouges et oranges, que les couleurs situées entre le centre et l'ancien cercle trop lumineux sont, comment dire ?, trop brillantes pour le rouge à 3 h, et tirant sur le marron pour l'orange, sur le gris pour le jaune.
Dans cette zone :


Ton avis ?


J'ai fouillé dans les dossiers de mes vieilles études (le mot "parabolic" me parlait) et j'ai retrouvé ça :


qui s'appuie tout simplement sur une fonction présente dans Lazarus, GraphUtil.DrawVerticalGradient :

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
{
  Draw gradient from top to bottom with parabolic color grow
}
procedure DrawVerticalGradient(Canvas: TCanvas; ARect: TRect; TopColor, BottomColor: TColor);
var
  y, h: Integer;
  r1, g1, b1: byte;
  r2, g2, b2: byte;
  dr, dg, db: integer;
 
 function GetColor(pos, total: integer): TColor;
 
   function GetComponent(c1, dc: integer): integer;
   begin
     Result := Round(dc / sqr(total) * sqr(pos) + c1);
   end;
 
 begin
   Result :=
      GetComponent(r1, dr) or
     (GetComponent(g1, dg) shl 8) or
     (GetComponent(b1, db) shl 16);
 end;
 
begin
  ExtractRGB(ColorToRGB(TopColor), r1, g1, b1);
  ExtractRGB(ColorToRGB(BottomColor), r2, g2, b2);
  dr := r2 - r1;
  dg := g2 - g1;
  db := b2 - b1;
  h := ARect.Bottom - ARect.Top;
  for y := ARect.Top to ARect.Bottom do
  begin
    Canvas.Pen.Color := GetColor(y - ARect.Top, h);
    Canvas.Line(ARect.Left, y, ARect.Right, y);
  end;
end;

Ce qui est dommage, c'est qu'ils aient mélangé la partie calcul et la partie utilisation du calcul (à partir de la ligne 31, h :=), mais au moins c'est directement utilisable.
Si ça t'inspire...

L'intervention d'une loi parabolique sur la moitié du domaine ([0 ; 1/2] ou [1/2 ; 1] selon les cas)

Pourrait-on envisager de déplacer la frontière, genre [0 ; 1/3] ? Histoire de rajouter un paramètre fluctuant de plus,

Bon dimanche,

[wiwaxia]

... J'ai fouillé dans les dossiers de mes vieilles études (le mot "parabolic" me parlait) et j'ai retrouvé ça :


qui s'appuie tout simplement sur une fonction présente dans Lazarus, GraphUtil.DrawVerticalGradient :

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
{
  Draw gradient from top to bottom with parabolic color grow
}
procedure DrawVerticalGradient(Canvas: TCanvas; ARect: TRect; TopColor, BottomColor: TColor);
var
  y, h: Integer;
  r1, g1, b1: byte;
  r2, g2, b2: byte;
  dr, dg, db: integer;
 
 function GetColor(pos, total: integer): TColor;
 
   function GetComponent(c1, dc: integer): integer;
   begin
     Result := Round(dc / sqr(total) * sqr(pos) + c1);
   end;
 
 begin     ...

Ce qui est dommage, c'est qu'ils aient mélangé la partie calcul et la partie utilisation du calcul (à partir de la ligne 31, h :=), mais au moins c'est directement utilisable.
Si ça t'inspire ...

Traduction rapide du code: GetComponent = Round(dc*(pos/total)²
Il intervient dans l'expression le carré d'une coordonnée (ou d'une différence de coordonnées): il s'agit bien d'une loi parabolique.
Le premier dégradé est donné à vue d'oeil (c'est le cas de dire ) par les relations linéaires (passons sur l'arrondi)

Code :

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

1
2
r:= 255*(1 - y); 
v:= 255*y

(y variant de 0 à 1 à partir du bas), et le deuxième par

Code :

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

1
2
r:= 255*Sqr(1 - y);
v:= 255*(1 - Sqr(1 - y));

ce qui a pour effet de déplacer la zone brune (r = v = 255/2 ~ 128) vers le bas:
y = 0.500 dans le premier cas,
y = 1 - 0.5^1/2 = 0.293 dans le deuxième.

... Pourrait-on envisager de déplacer la frontière, genre [0 ; 1/3] ? Histoire de rajouter un paramètre fluctuant de plus, ...

Parfaitement, à condition de réécrire les équations, et de remplacer le seuil (0.5) par une variable (X0) ou son complément (1 - X0). Ce qu'une boîte noire ne fera probablement pas à ta place.
Mais que cela ne trouble pas cette journée. Bon dimanche .

[Jipété]

Bonjour,

avant d'attaquer les rendus paraboliques, je voudrais revenir deux secondes (enfin ça fera bien quelques posts, ) sur une nouveauté qui m'a surpris.

Voulant avoir une possibilité simple et sympathique de redimensionnement de la fiche et donc du cercle qu'elle embarque, j'ai revu de fond en comble la création du bitmap de matrices (le fameux "map"), et j'en ai profité pour me faciliter la tâche en partant de l'idée que ce bitmap devait avoir sa largeur divisible par 24, ce qui est chose faite, et comme ça j'ai 24 colonnes de couleurs différentes mais de même taille, trop bien.

Ce que je n'ai cependant pas compris, c'est qu'il a fallu que je mette mes grosses mains dans la petite boîte noire qui dessine le cercle à partir du rectangle, qu'on en juge à gauche avec le résultat du code d'origine. Et pour me sortir de cette misère, il m'a fallu transformer le parcours d'analyse de la matrice de l'utilisation de pRGBtriple à celle de pRGBquad, et je n'ai pas la moindre idée de pourquoi, mais en attendant ça fonctionne, à droite.


Après pas mal de tâtonnements, quand même...

Code pascal :

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

1
2
distance := round(sqrt(somme_cotesaucarre * 2));// original
distance := round(sqrt(somme_cotesaucarre div 2));

Et les résultats, de g à dr :

L'image de droite nous gratifie d'un point noir en plein centre, va falloir le quicher,

Code pascal :

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

1
2
distance := round(sqrt(somme_cotesaucarre));
distance := round(sqrt(somme_cotesaucarre * 4));

Image de droite, notez le point blanc à presque 3 h, et selon la taille de la fiche, il y en a presque plein la circonférence (je ne mets pas d'image, elle est grande, et on en voit tout plein sur le "ballon de plage", plus bas).
À ce propos, ai remaqué que si points blancs, il me suffisait de maximiser la fenêtre pour les faire disparaître et, une fois disparus, ils le restent .

On s'approche donc du but avec distance := trunc(sqrt(somme_cotesaucarre * 4));, 2^e image du post, trunc au lieu de round.
Il n'y a plus de points blancs mais j'ai peur qu'ils réapparaissent au détour d'un contexte malchanceux, d'autant plus que certaines choses qui pourraient sembler évidentes

Code pascal :

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

1
2
3
4
//distance := round(sqrt(somme_cotesaucarre * 4));// plein de points blancs en périphérie
  distance := trunc(sqrt(somme_cotesaucarre*4)); // il n'y en a plus
  idx := (distance * diam) + round(ToDegrees(Phase * rapport_diam_sur360));
  pb[pos_px] := pxsourceQ[idx]; // génération du bitmap pixel à pixel

ne le sont pas du tout, au niveau du résultat (1 seul round final comme suggéré par wiwaxia [et j'aurais pu être d'accord] au lieu de 2 ou 1 round + 1 trunc) :

Code pascal :

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

1
2
3
4
5
  distances := sqrt(somme_cotesaucarre * 4);
//idx := round((distances * diam) + ToDegrees(Phase * rapport_diam_sur360)); // kc
// dessus ou dessous, c'est pareil, c'est kc
  idx := trunc((distances * diam) + ToDegrees(Phase * rapport_diam_sur360)); // kc
  pb[pos_px] := pxsourceQ[idx]; // génération du bitmap pixel à pixel

Qu'en pensent nos amis les matheux ?

Et après on s'attaque au parabolic, promis !

[wiwaxia]

... Ce que je n'ai cependant pas compris, c'est qu'il a fallu que je mette mes grosses mains dans la petite boîte noire qui dessine le cercle à partir du rectangle, qu'on en juge à gauche avec le résultat du code d'origine. Et pour me sortir de cette misère, il m'a fallu transformer le parcours d'analyse de la matrice de l'utilisation de pRGBtriple à celle de pRGBquad, et je n'ai pas la moindre idée de pourquoi, mais en attendant ça fonctionne, à droite ...

C'est quoi, le RGB triple ou quad ?
En tous cas, ton cercle chromatique comporte 4*24 = 96 secteurs; ton paramètre de teinte, qui parcourt l'échelle de ta palette, est ici 96 fois trop grand; il doit y avoir comme un défaut dans l'une de tes formules ...

... L'image de droite nous gratifie d'un point noir en plein centre, va falloir le quicher ...

Attention à la parité des dimensions de l'image ! Une image centrée sur un cercle doit présenter des dimensions impaires

... sinon le recours aux fonctions Trunc(.) et Round(.) (je ne vise personne ) achève de semer la panique.

... Il n'y a plus de points blancs mais j'ai peur qu'ils réapparaissent au détour d'un contexte malchanceux, d'autant plus que certaines choses qui pourraient sembler évidentes ... / ...ne le sont pas du tout, au niveau du résultat

Farcir le code de fonctions discontinues transforme le calcul en jeu de hasard: les scintillements qui ponctuent la circonférence montrent que tu n'a pas défini correctement la frontière entre intérieur et extérieur du cercle: il y a un no man's land lié aux effets sporadiques d'un Trunc(...) (ou autre) planqué dans l'algorithme.

Quand aux irisations, je pense qu'elles sont dues au dopage de la phase, qui là encore se voit imposer des variations beaucoup trop grandes: il faudrait les compter, comme les cernes d'un tronc d'arbre ...

Remarque: on retrouve ici encore le cercle lumineux diffus à mi-rayon ... Tes algorithmes susciteraient-ils des phénomènes paranormaux ?

[anapurna]

C'est quoi, le RGB triple ou quad ?

c'est le nombre d'element constituant le RGB ... avec l'evolution ils y ont adjoint une valeur supplémentairement
appelé canal Alpha celui-ci determine la transparence et de se fait augmente la posibilité du nombre de couleurs

...

Attention à la parité des dimensions de l'image ! Une image centrée sur un cercle doit présenter des dimensions impaires

... sinon le recours aux fonctions Trunc(.) et Round(.) (je ne vise personne ) achève de semer la panique.

et c'est normal que le nombre doit etre impaire car pour que se soit centré le point milieux ne peut etre divisible
1..3..5..7...........99...
le plus simple est de verifier la taille minimal de ton image si elle est paire tu retire 1 pixel sinon tu prend la taille mini

attention le trunc et le round ne fait absolument pas la même chose
le round défini selon la valeur décimal si il arrondi en plus ou en moins
le trunc prend la valeur entière simplement
il ne faut s'en servir que pour l'affichage tes calcul doivent être fait avec le plus de précision possible

[Jipété]

C'est quoi, le RGB triple ou quad ?

C'est une autre représentation du pixel, très utilisée quand on joue se fait mal à la tête avec Scanline.
Il y a des pixels avec trois composants : R, G, B d'où le triple, c'est le pixel classique, de base, et celui qui introduit le canal Alpha occupe un channel de plus d'où le Quad : RGB et A.

ton paramètre de teinte, qui parcourt l'échelle de ta palette, est ici 96 fois trop grand; il doit y avoir comme un défaut dans l'une de tes formules...

Tout est là

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
    // parcours du carré incluant le cercle :
    aBmp.BeginUpdate();
    for h := -rayon to rayon do begin
      h_aucarre := h*h;
      pb := pRGBQuad(aBmp.RawImage.GetLineStart(h+ct)); // ct c'est un offset de la longueur du rayon -- tiens d'ailleurs ça me donne une idée...
      for w := -rayon to rayon do begin
        pos_px := w+cl; // idem pour cl
        somme_cotesaucarre := w*w + h_aucarre;
        //if somme_cotesaucarre <= rayonaucarre then // on est "dans" le cercle
        if somme_cotesaucarre < rayonaucarre then // on est mieux "dans" le cercle
        // rayonaucarré c'est l'hypoténuse au carré
        begin
          distance := trunc(sqrt(somme_cotesaucarre*4));// serait ok avec cette nouvelle version
 
          IF w < 0 THEN Phase:= (-arctan(h/w) + Pi) // on est à gauche dans le carré du cercle
                   ELSE Phase:= (-arctan(h/w)); // on est à droite " " 
 
          idx := (distance * diam) + round(ToDegrees(Phase * rapport_diam_sur360));
          pb[pos_px] := pxsourceQ[idx]; // "Q" pour Quad  :je prends le pixel qui va bien dans la source carrée pour l'insérer dans le bitmap du cercle
        end;
      end;
    end;
    aBmp.EndUpdate();

Attention à la parité des dimensions de l'image ! Une image centrée sur un cercle doit présenter des dimensions impaires

OK, je reverrai cet aspect.
(Je sens qu'il va y avoir du sport...)

Farcir le code de fonctions discontinues transforme le calcul en jeu de hasard

Il n'y en a pas plus que ce que tu as vu ci-dessus.
Le bitmap "map" doit être bon car si je zappe l'affichage du cercle le dégradé est parfait (aux petites retouches de teintes près), donc si c'est quelque part c'est dans ce bout de code là-haut.

c'est le processeur qui se charge d'effectuer la conversion i:= n MOD 256 ...

Pas compris ce que ça vient faire ici, ça...

Remarque: on retrouve ici encore le cercle lumineux diffus à mi-rayon ...

Quel coup d'œil ! Moi je ne le vois pas (c'est mortel ces irisations).

Tes algorithmes susciteraient-ils des phénomènes paranormaux ?

Oh ça, ça ne m'étonnerait qu'à moitié ! Ces machines sont d'un capricieux, des fois on se demande...

[wiwaxia]

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
    // parcours du carré incluant le cercle :
    aBmp.BeginUpdate();
    for h := -rayon to rayon do begin
      h_aucarre := h*h;
      pb := pRGBQuad(aBmp.RawImage.GetLineStart(h+ct)); // ct c'est un offset de la longueur du rayon -- tiens d'ailleurs ça me donne une idée...
      for w := -rayon to rayon do begin
        pos_px := w+cl; // idem pour cl
        somme_cotesaucarre := w*w + h_aucarre;
        //if somme_cotesaucarre <= rayonaucarre then // on est "dans" le cercle
        if somme_cotesaucarre < rayonaucarre then // on est mieux "dans" le cercle
        // rayonaucarré c'est l'hypoténuse au carré
        begin
          distance := trunc(sqrt(somme_cotesaucarre*4));// serait ok avec cette nouvelle version
 
          IF w < 0 THEN Phase:= (-arctan(h/w) + Pi) // on est à gauche dans le carré du cercle
                   ELSE Phase:= (-arctan(h/w)); // on est à droite " " 
 
          idx := (distance * diam) + round(ToDegrees(Phase * rapport_diam_sur360));
          pb[pos_px] := pxsourceQ[idx]; // "Q" pour Quad  :je prends le pixel qui va bien dans la source carrée pour l'insérer dans le bitmap du cercle
        end;
      end;
    end;
    aBmp.EndUpdate();

1°) Il intervient deux fonctions discontinues

Code :

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

1
2
distance := trunc(sqrt(somme_cotesaucarre*4));// serait ok avec cette nouvelle version
idx := (distance * diam) + round(ToDegrees(Phase * rapport_diam_sur360));

L'arrondi ne devrait intervenir que dans l'expression finale de l'indice:
idx:= Round(...)

2°) L'expression n'est pas homogène:

Code :

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

idx := (distance * diam) + round(ToDegrees(Phase * rapport_diam_sur360));

(distance * diam) est une surface, et tu y ajoute un angle.
Je verrais plutôt:

Code :

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

idx := (distance / diam) + round(ToDegrees(Phase * rapport_diam_sur360));

même si ce n'est pas obligatoirement juste.

3°) La suite non plus ne m'inspire pas: je suppose que ToDegrees est une fonction de ton cru permettant de passer des radians aux degrés, donc à multiplier l'angle exprimé en radians par le facteur 360/(2*Pi) = 180/Pi;
le deuxième terme serait donc:
Round((360/(2*Pi))*Phase*Diam/360) = Round(Phase*Diam/(2*Pi))
Cela paraît juste, mais le facteur 360 n'a pas de raison d'intervenir.

Mais il faudrait ensuite multiplier par (Distance/Diam) pour avoir l'indice de ta palette ! Le diamètre est lui aussi inutile ... L'expression se réduit donc à:
idx:= Distance*Phase/(2*Pi)
et comme je ne saurais infliger à quiconque des souffrances inutiles ,

Code :

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

idx:= Round(Distance*Phase/(2*Pi))

Je ne fais en cela que reprendre la remarque pertinente d'anapurna

... il ne faut s'en servir que pour l'affichage tes calculs doivent être faits avec le plus de précision possible

Je dois m'arrêter là.