Discussion :

[wiwaxia]

À propos de la variabilité des résultats sur les nombres flottants (#35):

... Il n'y a donc rien de fiable à comparer des résultats produits dans des environnements différents et ça, c'est (pour moi) une grosse catastrophe : on l'a vu en comparant les dégradés ...

Il faut toujours utiliser le plus lourd format de réels (de type Extended), et ce dès la déclaration des données.
anapurna a fourni des indications à ce sujet.
De ce point de vue, les versions Turbo/Virtual/Free du Pascal utilisent le standard le plus précis: la précision atteint 2^-63.
Il en est probablement de même pour Lazarus et Delphi.
Real types

Il se peut aussi que les fonctions disponibles dans un langage donné ne soit pas calculées avec la précision maximale, pour des raisons d'efficacité. C'est en se lançant dans des vérifications semblables à celles que tu as faites que l'on peut découvrir des approximations cachées - expérience effectivement déplaisante.
Il m'a fallu 12 ans pour m'apercevoir qu'une calculatrice (version maintenant ancienne) de marque réputée, calculait les déterminants avec 12 chiffres seulement, au lieu des 14 disponibles .

Ceci dit, je ne pense pas que ces incertitudes affectent sérieusement les calculs et changements de paramètres concernant les couleurs, pour les quelles les données non entières comportent 4 ou 5 chiffres.
Les couleurs impossibles (j'ai cherché, sans trouver de références autres que neurologiques) sont celles pour lesquelles les données envisagées correspondent à des triplets (r, v, b) hors du domaine habituel [0 ; 255]³.
Couleur interdite

[foetus]

La chose se cache là-dedans (à la fin de colorsliders.js) :

Tu t'es gouré le return est dans un bloc si

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
    $.fn.ColorPickerSliders.lch2rgb = function(lch, invalidcolorsopacity) {
        if (typeof invalidcolorsopacity === "undefined") {
            invalidcolorsopacity = 1;
        }
        var rgb = $.fn.ColorPickerSliders.XYZ2rgb($.fn.ColorPickerSliders.CIELab2XYZ($.fn.ColorPickerSliders.CIELCH2CIELab(lch)));
        if ($.fn.ColorPickerSliders.isGoodRgb(rgb)) {
            if (lch.hasOwnProperty('a')) {
                rgb.a = lch.a;
            }
            rgb.isok = true;
            return rgb;
        }
        var tmp = $.extend({}, lch),
            lastbadchroma = tmp.c,
            lastgoodchroma = -1,
            loops = 0;
        do {
            ++loops;
            tmp.c = lastgoodchroma + ((lastbadchroma - lastgoodchroma) / 2);
            rgb = $.fn.ColorPickerSliders.XYZ2rgb($.fn.ColorPickerSliders.CIELab2XYZ($.fn.ColorPickerSliders.CIELCH2CIELab(tmp)));
            if ($.fn.ColorPickerSliders.isGoodRgb(rgb)) {
                lastgoodchroma = tmp.c;
            } else {
                lastbadchroma = tmp.c;
            }
        } while (Math.abs(lastbadchroma - lastgoodchroma) > 0.9 && loops < 100);
        if (lch.hasOwnProperty('a')) {
            rgb.a = lch.a;
        }
        rgb.r = Math.max(0, rgb.r);
        rgb.g = Math.max(0, rgb.g);
        rgb.b = Math.max(0, rgb.b);
        rgb.r = Math.min(255, rgb.r);
        rgb.g = Math.min(255, rgb.g);
        rgb.b = Math.min(255, rgb.b);
        if (invalidcolorsopacity < 1) {
            if (rgb.hasOwnProperty('a')) {
                rgb.a = rgb.a * invalidcolorsopacity;
            } else {
                rgb.a = invalidcolorsopacity;
            }
        }
        rgb.isok = false;
        return rgb;
    };

Et je tiens à préciser un truc : un autre problème du JavaScript, c'est qu'il travaille qu'en flottant (il ne connait pas la notion d'entier même lorsque tu calcules 1+1).
Regarde sur les Internets pour plus de précisions


Conseil : le code Web est souvent mimifié (c'est à dire on supprime les espaces, les tabulations et les fins de ligne inutiles). Il faut passer par un outil (soit en ligne soit en ligne de commande) comme Tidy (version JavaScript) pour remettre en forme le code.

[Jipété]

Tu t'es gouré le return est dans un bloc si

Tutafait !
J'avais un peu trop mimifié, histoire d'aller à l'essentiel (trop d'accolades et de sauts de lignes tuent la lisibilité globale, pour moi).
Bon, ben...

Cent fois sur le métier remets-toi à l'ouvrage

Il m'a fallu 12 ans pour m'apercevoir qu'une calculatrice (version maintenant ancienne) de marque réputée, calculait les déterminants avec 12 chiffres seulement, au lieu des 14 disponibles .

Tout vient à point à qui sait attendre
Mieux vaut tard que jamais

Les couleurs impossibles [...] sont celles pour lesquelles les données envisagées correspondent à des triplets (r, v, b) hors du domaine habituel [0 ; 255]³.
Couleur interdite

Tutafait !
C'est ce qui m'avait tellement interpellé dans les premiers résultats (calculateurs de Bruce Lindbloom, de EasyRGB, avec des valeurs négatives ou au-delà de 255) que j'avais rejeté ça, comme un imbécile, alors que c'est la clé du truc !


Je sais sur quoi il faut que je travaille, maintenant...

[wiwaxia]

Je reviens sur une partie du code que tu as récemment donné (#33), qui contient d'énormes difficultés; je pense que tu as été piégé par le laxisme de Javascript ⁽¹⁾, qui est apparemment capable d'avaler tous les codes qui lui sont donnés en pâture.
Heureusement, je viens de remettre la main sur un document fiable, concernant le passage des coordonnées de l'espace de couleur aux triplets (r, g, b).
Voir sRGB.

Voilà le code de ta fonction de conversion;

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
 
    $.fn.ColorPickerSliders.XYZ2rgb = function(XYZ) {
        var rgb = {};
 
        // Observer = 2°, Illuminant = D65
        XYZ.x = XYZ.x / 100;        // X from 0 to  95.047
        XYZ.y = XYZ.y / 100;        // Y from 0 to 100.000
        XYZ.z = XYZ.z / 100;        // Z from 0 to 108.883
 
        rgb.r = XYZ.x *  3.2406 + XYZ.y * -1.5372 + XYZ.z * -0.4986;
        rgb.g = XYZ.x * -0.9689 + XYZ.y *  1.8758 + XYZ.z *  0.0415;
        rgb.b = XYZ.x *  0.0557 + XYZ.y * -0.2040 + XYZ.z *  1.0570;
 
        if (rgb.r > 0.0031308) rgb.r = 1.055 * (Math.pow(rgb.r, 0.41666667)) - 0.055; else rgb.r = 12.92 * rgb.r;
        if (rgb.g > 0.0031308) rgb.g = 1.055 * (Math.pow(rgb.g, 0.41666667)) - 0.055; else rgb.g = 12.92 * rgb.g;
        if (rgb.b > 0.0031308) rgb.b = 1.055 * (Math.pow(rgb.b, 0.41666667)) - 0.055; else rgb.b = 12.92 * rgb.b;
 
        rgb.r = Math.round(rgb.r * 255);
        rgb.g = Math.round(rgb.g * 255);
        rgb.b = Math.round(rgb.b * 255);
 
        return rgb;

1°) Il est d'abord question de 2 triplets de réels, rapportés de fait à la valeur maximale du terme médian (y), dont les valeurs sont au plus égales à environ 100 (pour le premier) et 1 (pour le second).

Code :

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

1
2
3
        XYZ.x = XYZ.x / 100;        // X from 0 to  95.047
        XYZ.y = XYZ.y / 100;        // Y from 0 to 100.000
        XYZ.z = XYZ.z / 100;        // Z from 0 to 108.883

C'est encore à ce niveau très clair, mais ce l'eût été encore plus si tu leur avais donné des noms différents: à ce jeu-là, le code peut déraper dans un beau merdier, ce qui n'a pas manqué de se produire par la suite.

2°) Un produit matriciel fournit ensuite les coefficients RGB linéaires, qui ne peuvent être que des réels compris entre 0 et 1, puisque tout entier strictement positif vérifie la condition:

Code :

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

 if (rgb.r > 0.0031308)

Il s'agit en fait des luminances relatives de chacune les couleurs fondamentales, à partir desquelles on passe aux coefficients relatifs standard (CsRVB) - l'exposant mentionné correspond en fait à (1/2.4):

Code :

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

1
2
3
4
 
        if (rgb.r > 0.0031308) rgb.r = 1.055 * (Math.pow(rgb.r, 0.41666667)) - 0.055; else rgb.r = 12.92 * rgb.r;
        if (rgb.g > 0.0031308) rgb.g = 1.055 * (Math.pow(rgb.g, 0.41666667)) - 0.055; else rgb.g = 12.92 * rgb.g;
        if (rgb.b > 0.0031308) rgb.b = 1.055 * (Math.pow(rgb.b, 0.41666667)) - 0.055; else rgb.b = 12.92 * rgb.b;

puis aux coefficients standard (sRVB), entiers au format Byte connus de tous:

Code :

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

1
2
3
        rgb.r = Math.round(rgb.r * 255);
        rgb.g = Math.round(rgb.g * 255);
        rgb.b = Math.round(rgb.b * 255);

Ton code deviendrait intelligible et aisément traduisible, dès l'attribution de noms différents (cela ne coûte rien) aux trois triplets concernés, par exemple:
RVBlin.r, ... etc, CsRVB.r ..., sRVB.r ... .
La résolution de tout problème exige au préalable de nommer clairement les grandeurs en cause.

J'espère que tu ne seras pas froissé par cette critique franche et constructive (comme on dit à la CGT) .

(1) Après tout ce qui a rapporté à ce sujet, ce n'est plus du code, mais de la pâtée pour chats

[Jipété]

Ne faîtes confiance à personne, et encore moins à vous-même.

Ben qu'est-ce qui nous reste, alors, pour avancer ?
Qui va me tenir la main pour m'aider à traverser cette jungle semée d'embûches nommée conversions d'espaces de couleurs ?

J'espère que tu ne seras pas froissé par cette critique franche et constructive (comme on dit à la CGT) .

Absolument pas, ne t'inquiète pas !

À ma décharge concernant tes remarques (que j'admets tout-à-fait, n'aie pas peur d'ôter tes gants avec moi, je peux tout entendre quand ça va dans la bonne direction), je dirais que si les noms ne sont pas parlants c'est que :

1. ils sont partout comme ça sur le web, à croire que Pierre recopie Paul qui a pompé sur Jacques (d'ailleurs certains codes notent en commentaire src : Bruce Lindbloom avec une url vers son site, par ex.)
2. in fine tout ça se retrouve dans une boîte noire où il n'y a plus aucune raison d'aller mettre les mains dedans, une fois la dernière couche de vernis passée. La preuve à l'utilisation, c'est que mes 3 curseurs (L, C, h°) pointent vers la même procédure, qui ne contient pas grand chose : panelDemo.Color := optLCH2ColorwithClamp(trkL.Position,trkC.Position,trkH.Position, ckbxD50to65.Checked, False);.

Détails :

• opt parce que c'est la fonction Javascript optimisée (multiplication par des constantes au lieu de division par des réels, remplacement de Power(x, 3) par x*x*x, suppression de codes redondants, etc. [mine de rien je passe de 50 à 35 millisecondes à l'exécution du dégradé, à la louche]) ;
• LCH2Color comme son nom l'indique ;
• withClamp because cette fonction embarque un test sur la nécessité de clamper, en attendant le développement des couleurs invalides-impossibles ;
• ckbxD50to65.Checked c'est une case à cocher pour activer ou pas la conversion D50 vers D65 (je ne sais pas encore si c'est nécessaire ou pas, en tout cas ça impacte un soupçon le rendu des couleurs) ;
• et False (ou True) c'est la prise en compte du clamp ou pas.

On referme la boîte, on visse à mort avec des vis indévissables, on remet une couche de vernis et roule ma poule !

[wiwaxia]

1)

Ben qu'est-ce qui nous reste, alors, pour avancer ? Qui va me tenir la main pour m'aider à traverser cette jungle semée d'embûches nommée conversions d'espaces de couleurs ? ...

Un minimum de réflexion et d'autocritique.
La traduction de l'une de tes fonctions en Pascal, et la découverte des absurdités qu'elle contenait, a déclenché ce matin la rédaction du précédent message.
Ton programme fonctionne à priori, et après réflexion sa traduction est tout à fait possible, en tenant compte des remarques exprimées.

2)

... ils sont partout comme ça sur le web, à croire que Pierre recopie Paul qui a pompé sur Jacques ...

Ce n'est pas un doute, mais une certitude. On peut même regrouper les sites selon le contenu des données.
La véritable question est la vérifiabilité des données: de bonnes références permettent de pallier à l'insuffisance ou l'obscurité d'une information.

3)

... in fine tout ça se retrouve dans une boîte noire où il n'y a plus aucune raison d'aller mettre les mains dedans, une fois la dernière couche de vernis passée ...
On referme la boîte, on visse à mort avec des vis indévissables, on remet une couche de vernis et roule ma poule !

Que les concepteurs aiment boucler leur travail une fois terminé la mise au point, c'est parfaitement compréhensible.
Mais pour tous les autres la notion de boîte noire est choquante, dès lors qu'ils cherchent à comprendre les calculs effectués: c'était bien ce qui te préoccupait jusque là.
Et la variabilité des données numériques, les contestations qui en découlent, alimentent leur désarroi.
C'est à la limite un problème de défaut d'information.

4)

... je dirais que si les noms ne sont pas parlants c'est que ...

Peu importe les noms (le style est une affaire privée), pourvu qu'ils ne soient pas identiques ! C'est cette avarice de moyens, gravement préjudiciable à la compréhension du code, qui m'a franchement agacé.
Tu as réagi tout aussi vivement, et avec encore plus d'éloquence, au sujet du laxisme du logiciel en cause (#30)

Non mais c'est quoi ce binz ?
J'ai tapé les 2 instructions (que je trouve stupides, au demeurant, et ça ne passerait pas en Pascal) et ça me sort ça :...

Truc de ouf' ! Tu m'étonnes que les fusées Ariane explosent au décollage, que des bagnoles passent en trombe régulateur bloqué aux péages et que la SNCF soit tout le temps en panne avec des machins pareils !
Et sinon, où veux-tu en venir avec ça ?
... mais pourquoi les développeurs écrivent-ils d'une manière illisible ?

5)

[*]opt parce que c'est la fonction Javascript optimisée (multiplication par des constantes au lieu de division par des réels, remplacement de Power(x, 3) par x*x*x, suppression de codes redondants, etc. [mine de rien je passe de 50 à 35 millisecondes à l'exécution du dégradé, à la louche]) ...

Bonnes remarques. Les fonctions et procédures d'appoint augmentent souvent le temps d'exécution, bien qu'elles paraissent alléger la rédaction du code. Tu pourrais dans la foulée vérifier si l'appel de bornage Clamp(u, Min, Max) remplace avantageusement les instructions:

Code :

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

1
2
IF (u<Min) THEN u:= Min;
IF (u>Max) THEN u:= Max;

6) Je ne suis pas curieux, mais j'aime bien savoir : dans quelle source trouve-t-on justement la fonction cube (Power(x, 3)) ? Je ne l'ai jamais rencontrée dans ce domaine, et tu n'en a pas donné le lien (#34)

PS: je suis intrigué par l'exposant (3), lignes (18) à (20) D'où viennent ces relations ?

[Jipété]

5) Bonnes remarques. Les fonctions et procédures d'appoint augmentent souvent le temps d'exécution, bien qu'elles paraissent alléger la rédaction du code. Tu pourrais dans la foulée vérifier si l'appel de bornage Clamp(u, Min, Max) remplace avantageusement les instructions:

Code :

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

1
2
IF (u<Min) THEN u:= Min;
IF (u>Max) THEN u:= Max;

Hé bien l'implémentation en Pascal fait la même chose :

Code Pascal :

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

1
2
3
4
5
function Clamp(x, mini, maxi: double): double; inline;
begin
  if x < mini then x := mini else if x > maxi then x := maxi;
  result := x;
end;

Ça devrait donc prendre plus ou moins le même temps.

6) Je ne suis pas curieux, mais j'aime bien savoir : dans quelle source trouve-t-on justement la fonction cube (Power(x, 3)) ? Je ne l'ai jamais rencontrée dans ce domaine, et tu n'en a pas donné le lien (#34)

-- Chez EasyRGB, (et c'est mal foutu : une fois sur la page, clique sur CIE-L*ab --> XYZ) c'est du pseudo-code, libre à chacun de l'écrire à sa sauce :

Code :

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

1
2
if ( var_Y^3  > 0.008856 ) var_Y = var_Y^3
else                       var_Y = ( var_Y - 16 / 116 ) / 7.787

et pareil pour X et Z.

-- Dans le code en Javascript dont on cause depuis deux jours :

Code javascript :

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

if (Math.pow(XYZ.y, 3) > 0.008856) XYZ.y = Math.pow(XYZ.y, 3); else XYZ.y = (XYZ.y - 0.137931034) / 7.787;

et pareil pour x et z.

-- Chez Chris, c'est aussi du Javascript avec une petite variante concernant Y :

Code javascript :

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

1
2
3
4
5
6
7
8
var κ = 24389/27;   // 29^3/3^3  903.296296
var ε = 216/24389;  // 6^3/29^3  0.00885645
// compute xyz
var xyz = [
	Math.pow(f[0],3) > ε ?   Math.pow(f[0],3)            : (116*f[0]-16)/κ,
	Lab[0] > κ * ε ?         Math.pow((Lab[0]+16)/116,3) : Lab[0]/κ,
	Math.pow(f[2],3)  > ε ?  Math.pow(f[2],3)            : (116*f[2]-16)/κ
];

-- Colormine et son C# :

Code c :

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

1
2
3
4
5
6
            var xyz = new Xyz
                {
                    X = white.X * (x3 > XyzConverter.Epsilon ? x3 : (x - 16.0 / 116.0) / 7.787),
                    Y = white.Y * (item.L > (XyzConverter.Kappa * XyzConverter.Epsilon) ? Math.Pow(((item.L + 16.0) / 116.0), 3) : item.L / XyzConverter.Kappa),
                    Z = white.Z * (z3 > XyzConverter.Epsilon ? z3 : (z - 16.0 / 116.0) / 7.787)
                };

-- Chez CodeProject, c'est un français qui code en VB.net et dont je ne retrouve pas le lien :

Code VB :

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

1
2
Dim delta As Double = 6.0 / 29.0
If fx > delta Then xyz.X = d65X * (fx * fx * fx) Else xyz.X = (fx - 16.0 / 116.0) * 3 * (delta * delta) * d65X

et pareil pour y et z.

-- Chez Bruce Lindbloom (site mal foutu, faut cliquer sur Math et là tu choisis source et destination dans le tableau lien corrigé), pseudo-code aussi mais impossible à copier-coller (langage spécifique aux formules mathématiques), avec des différences par rapport aux autres.

-- Et enfin j'ai lu du bien d'un javascript nommé chroma.js :

Code Javascript :

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
  lab_xyz = function(t) {
    if (t > LAB_CONSTANTS.t1) {
      return t * t * t;
    } else {
      return LAB_CONSTANTS.t2 * (t - LAB_CONSTANTS.t0);
    }
  };
 
  LAB_CONSTANTS = {
    Kn: 18,
    Xn: 0.950470,
    Yn: 1,
    Zn: 1.088830,
    t0: 0.137931034,
    t1: 0.206896552,
    t2: 0.12841855,
    t3: 0.008856452
  };

Et comme si ça ne suffisait pas, il y a aussi ceux qui utilisent ^(1/3) (dans la formule de Pauli, il parait, mais ça me dépasse) : Jean Delmas dans son bouquin dont j'ai déjà causé, mais il y a aussi des scripts en js et du code en C (Pascal Getreuer et son sympathique Colorspace, déjà cité).

En fait, il faudrait que je fasse un système pour utiliser au choix une parmi les n manières dont je dispose, pour comparer, mais j'ai peur qu'au final je ne me retrouve avec des images identiques à l'œil, seule une analyse pixel par pixel pouvant trier tout ça.
Faudrait vraiment que je n'aie rien à faire !

[foetus]

Et comme si ça ne suffisait pas, il y a aussi ceux qui utilisent ^(1/3)

C'est la racine cubique

• 3 x 3 x 3 = 27, alors la racine cubique de 27 c'est 3
• 4 x 4 x 4 = 64, alors la racine cubique de 64 c'est 4

[wiwaxia]

1) Je ne mettais pas les langages en comparaison, mais le choix entre la paire d'instructions

Code :

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

1
2
IF (u<Min) THEN u:= Min;
IF (u>Max) THEN u:= Max;

et la procédure (ou fonction) équivalente.
À ce sujet, j'aurais spontanément choisi une procédure comme:

Code :

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

1
2
3
4
5
6
PROCEDURE Clamp(VAR u: TypeV; Min, Max: TypeV);
  VAR v: TypeV;
  BEGIN
     v:= u;                  IF (v<Min) THEN v:= Min;
    IF (v>Max) THEN v:= Max; u:= v
  END;

et ta fonction me donne l'idée d'une variante:

Code :

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

1
2
3
4
5
6
7
PROCEDURE Clamp(VAR u: TypeV; Min, Max: TypeV);
  VAR v: TypeV;
  BEGIN
     v:= u;                 
     IF (v<Min) THEN u:= Min
                ELSE IF (v>Max) THEN u:= Max
  END;

Il serait intéressant de comparer les temps d'exécution.

2) Merci pour les infos. J'ai trouvé fortuitement un lien en relation implicite avec la fonction en cause:
Définition CIE 1976
Il faudra recouper ceci avec ce que tu m'as donné, et cela n'a rien d'évident. Je sens que ça va être laborieux.

[anapurna]

salut

Code :

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

 3^3 = 9^(1/3) = 3

^(1/N) c'est la racine Nieme donc l'inverse de la Puissance

tu peut aussi faire cela sans passer par une variable intermédiaire

Code :

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

1
2
3
4
5
6
7
8
9
 
PROCEDURE Clamp(VAR u: TypeV; Min, Max: TypeV);
BEGIN
     IF (u<Min) THEN 
         u:= Min
     ELSE 
     IF (u>Max) THEN 
        u:= Max
 END;

[foetus]

Code :

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

 3^3 = 9^(1/3) = 3

Tu t'es troué

• 3 ^ 3 = 27 et non 3
• 27 ^ (1/ 3) = 3 (3 x 3 x 3 = 27)
• 9 ^ (1/ 3) = 2.08 et non 3 (2.08 x 2.08 x 2.08 ~ 9)

[Jipété]

Et il y a plus grave...

colorspace.c de P. Getreuer :

Code C :

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

1
2
3
#define LABF(t)	\
	((t >= 8.85645167903563082e-3) ? \
	pow(t,0.333333333333333) : (841.0/108.0)*(t) + (4.0/29.0))

Réécrit en Lazarus :

Code Pascal :

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

1
2
3
if t >= 0.0885645167903563 
then result := power(t, 0.333333333333333) 
else result := (841.0/108.0)*(t) + (4.0/29.0);

Posons t := 0.5; et faisons le boulot :
if t >= 0.0885645167903563 then result := power(t, 0.333333333333333); donc t vaut 0.5^0.3_plein_de_trois, soit 0.7937

Si je fais la même manip avec EasyRGB par exemple, on va avoir result := power(t, 3); soit 0.125.

Ce qui se passe ensuite, c'est la conversion xyz2rgb et on va donc lui passer soit 0.7937 soit 0.125.
Avec EasyRGB (qui utilise ^3) comme avec le .c (qui utilise ^0.3...) on convertit les valeurs en fonction de l'illuminant (D65 2°) ainsi :

Code pascal :

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

1
2
3
    X := 0.95047 * X;
    Y := 1.00000 * Y;
    Z := 1.08883 * Z;

puis la conversion vers RGB à proprement parler :

Code pascal :

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

1
2
3
    R := X *  3.2406 + Y * -1.5372 + Z * -0.4986;
    G := X * -0.9689 + Y *  1.8758 + Z *  0.0415;
    B := X *  0.0557 + Y * -0.2040 + Z *  1.0570;

En partant de l'hypothèque (pour simplifier les calculs de *cette* démonstration) que X = Y = Z,
on va donc avoir (avec ^3) :

Code :

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

1
2
3
    X := 0.95047 * 0.7937; = 0.7544
    Y := 1.00000 * 0.7937; = 0.7937
    Z := 1.08883 * 0.7937; = 0.8642

ou (avec ^0.3...)

Code :

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

1
2
3
    X := 0.95047 * 0.1250; = 0.1189
    Y := 1.00000 * 0.1250; = 0.1250
    Z := 1.08883 * 0.1250; = 0.1361

puis (avec ^3)

Code :

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

1
2
3
    R := 0.7544 *  3.2406 + 0.7937 * -1.5372 + 0.1361 * -0.4986; =  2.4448 - 1.2201 - 0.0678 = 1.1569 
    G := 0.7544 * -0.9689 + 0.7937 *  1.8758 + 0.1361 *  0.0415; = -0.7309 + 1.4888 + 0.0056 = 0.7635
    B := 0.7544 *  0.0557 + 0.7937 * -0.2040 + 0.1361 *  1.0570; =  0.0420 - 0.1619 + 0.1439 = 0.0240

ou (avec ^0.3...)

Code :

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

1
2
3
    R := 0.1189 *  3.2406 + 0.1250 * -1.5372 + 0.1361 * -0.4986; =  0.3853 - 0.1921 - 0.0679 = 0.1253
    G := 0.1189 * -0.9689 + 0.1250 *  1.8758 + 0.1361 *  0.0415; = -0.1152 + 0.2345 + 0.0056 = 0.1249 
    B := 0.1189 *  0.0557 + 0.1250 * -0.2040 + 0.1361 *  1.0570; =  0.0066 - 0.0255 + 0.1438 = 0.1249

(pur hasard que les deux derniers résultats soient identiques)

Je ne comprends pas comment (et pourquoi) certains programmes utilisent ^3 quand d'autres calculent avec ^0.3..., car au bout du compte les valeurs R, G et B sont bien différentes, même si à l'œil c'est indiscernable.
Et ça perturbe mes réflexions...

[wiwaxia]

a = b^(3) équivaut à b = a^(1/3) ~ a^(0.333333) (pour s'en tenir à une précision raisonnable - quinze chiffres significatifs, c'est peut-être un peu beaucoup ...)

Je n'ai pas eu le temps d'approfondir, et suppose qu'il s'agit une simple question de fonction réciproque ... Enfin, j'espère

La journée a été longue pour tout le monde.

[anapurna]

Tu t'es troué

• 3 ^ 3 = 27 et non 3
• 27 ^ (1/ 3) = 3 (3 x 3 x 3 = 27)
• 9 ^ (1/ 3) = 2.08 et non 3 (2.08 x 2.08 x 2.08 ~ 9)

effectivement j'ete parti avec un exemple basique en puissance de 2 puis j'ai changé au dernier moment et paf ... j'ai oublié de refaire tout les calcul

[Jipété]

Bonjour,

En fait, il faudrait que je fasse un système pour utiliser au choix une parmi les n manières dont je dispose, pour comparer [...]

je l'avais envisagé, je l'ai fait ! Ch'suis un grand malade, ça se soigne, docteur ?

Résultats des courses : j'ai 5 fonctions différentes et à l'exécution 5 images identiques (sauf peut-être au niveau des pixels, mais à l'œil dans le dégradé ça ne se voit pas du tout, comme je le supposais).

Le seul truc qui m'a turlupiné un peu, c'est ce qui est noté ci-dessous :

Code pascal :

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

1
2
3
4
//javascript chroma.js : test identique à codeproject, les return identiques à easyrgb
if (t > 0.2068965520) then t := t*t*t else t := (t - 16 / 116) / 7.787;
// easyrgb
if (t*t*t > 0.008856) then t := t*t*t else t := (t - 16 / 116) / 7.787;

Si je fais Power(0.008856, 0.33333) ça me donne 0.206893360394, j'en conclus qu'à la 6^e décimale près, ces tests sont identiques, donc leurs résultats aussi. Correct ?


Bref, in fine il reste la différence au niveau du traitement du Y, et là, deux grandes familles :

-- Easyrgb et son "clan" (javascript_sliders, chroma.js, codeproject en VB.net [mis à part le test, relire juste au-dessus]) d'un côté, où X, Y et Z sont traités de la même manière :

Code pascal :

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

if (t*t*t > 0.008856) then t := t*t*t else t := (t - 16 / 116) / 7.787;

-- et ceux qui font dans le sophistiqué (Bruce, Chris, Colormine) avec le traitement particulier du Y :

Code pascal :

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

if L > 903.296296 * 0.008856 then Y := power( (L + 16) / 116, 3) else Y := L / 903.296296;

-- Mais pour X et Z Colormine fait comme la bande à Easyrgb quand Chris et Bruce font bande à part :

Code pascal :

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

if (t*t*t > 0.008856) then t := t*t*t else t := (t * 116 - 16) / 903.296296;

Ouf !
Quelle aventure !
D'autant plus que certains utilisent 0.008856 quand d'autres "descendent" jusqu'à 0.00885645167903563082 (P. Getreur et son Colorspace) ; est-ce que c'est important ?


Et les couleurs impossibles, dans tout ça ?
Ben ça va traîner un peu, cet aprème je ne suis pas libre, et avec cette histoire de clamping rajouté ça fonctionne pas trop mal : le dégradé est sympa, je trouve, beaucoup plus doux que le dégradé violent en RGB de base qu'on rencontre partout :
.

Je vais voir un peu de ce côté ce que donne l'utilisation finale.

À suivre,

[wiwaxia]

... Le seul truc qui m'a turlupiné un peu, c'est ce qui est noté ci-dessous :

Code pascal :

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

1
2
3
4
//javascript chroma.js : test identique à codeproject, les return identiques à easyrgb
if (t > 0.2068965520) then t := t*t*t else t := (t - 16 / 116) / 7.787;
// easyrgb
if (t*t*t > 0.008856) then t := t*t*t else t := (t - 16 / 116) / 7.787;

Si je fais Power(0.008856, 0.33333) ça me donne 0.206893360394, j'en conclus qu'à la 6^e décimale près, ces tests sont identiques, donc leurs résultats aussi. Correct ? ...

Les conditions (t > 0.2068965520) et (t³ > 0.2068965520³) sont logiquement équivalentes, et comme 0.2068965520³ = 0.008856451714 ,
il en va numériquelment de même, d'une manière approchée, pour
(t > 0.2068965520) et (t³ > 0.008856).

L'intervention du cube n'est donc pas nécessaire, et elle ralentit sûrement le calcul.
Son écriture (t*t*t) est par ailleurs choquante . Du plus mauvais effet.
Tu ne pourrais pas au moins écrire:

Code :

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

T2:= Sqr(t); T3:= t * T2

il n'est pas sûr que ce soit plus lent ... La fonction cube(x) n'est-elle pas non plus disponible ?

Quant aux constantes ... ne peux-tu prévoir un calcul préalable de l'exposant, conduisant à sa valeur exacte ?

Code :

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

CONST n = 1 / 3;

[wiwaxia]

... D'autant plus que certains utilisent 0.008856 quand d'autres "descendent" jusqu'à 0.00885645167903563082 (P. Getreur et son Colorspace) ; est-ce que c'est important ? ...

Non, c'est franchement débile - de la part de professionnels.

# Au sujet des deux palettes:
¤ dans la première, les couleurs primaires (r, v, b) sont diluées au point de ne pas apparaître, et quatre arcs de paraboles sont nettement discernables (quoique d'une manière diffuse), laissant deviner les fonctions de pondération sous-jacentes: tu aurais pu faire aussi bien (et même mieux) avec un petit programme, sans subir le calvaire de ces derniers jours.
¤ C'est le contraire pour la deuxième, où elles s'y étalent tant qu'il ne subsiste plus qu'une zone très étroite pour les trois autres (j, c, m); et la transition de l'ombre à la clarté est trop rapide.

[Jipété]

Yop !

# Au sujet des deux palettes:
¤ dans la première, les couleurs primaires (r, v, b) sont diluées au point de ne pas apparaître,

C'est l'effet LCh°, ça !
Une modification de C intervient dans le rendu de la couleur finale (ça se voit bien avec l'exemple des sliders sur le site codé en Javascript), et il est difficile de faire apparaître 3 dimensions dans un affichage prévu pour 2,

quatre arcs de paraboles sont nettement discernables (quoique d'une manière diffuse), laissant deviner les fonctions de pondération sous-jacentes: tu aurais pu faire aussi bien (et même mieux) avec un petit programme, sans subir le calvaire de ces derniers jours.

Le calvaire m'a fait apprendre des choses, et le petit programme, si tu as une source je veux bien la lire, sinon il faudra attendre que je gère les couleurs impossibles.

L'intervention du cube n'est donc pas nécessaire, et elle ralentit sûrement le calcul.

Cube supprimé, et effectivement je gagne du temps à l'exécution !

Son écriture (t*t*t) est par ailleurs choquante . Du plus mauvais effet.
Tu ne pourrais pas au moins écrire:

Code :

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

T2:= Sqr(t); T3:= t * T2

il n'est pas sûr que ce soit plus lent ... La fonction cube(x) n'est-elle pas non plus disponible ?

Je n'ai eu l'idée d'utiliser cette triple multiplication que récemment, en la voyant dans d'autres codes : en regardant la fonction power en Lazarus, je me dis que ceux qui ont choisi les multiplications ont dû le faire en connaissance de cause (oui, il faudrait faire des tests pointus et poussés, mais bon...)
Et, non, cube n'est pas dispo.

Exemple (curieux) trouvé chez P. Getreuer dans son Colorspace.c :

Code C :

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

1
2
3
4
5
6
7
#define LABF(t)	\
	((t >= 8.85645167903563082e-3) ? \
	pow(t,0.333333333333333) : (841.0/108.0)*(t) + (4.0/29.0))
 
#define LABINVF(t)	\
	((t >= 0.206896551724137931) ? \
	((t)*(t)*(t)) : (108.0/841.0)*((t) - (4.0/29.0)))

Un coup il utilise pow et un coup les multiplications ! Go figure...

Quant aux constantes ... ne peux-tu prévoir un calcul préalable de l'exposant, conduisant à sa valeur exacte ?

Code :

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

CONST n = 1 / 3;

J'y avais pensé puis j'ai supposé que ce travail relevait des tâches du compilateur. Non ?

Merci pour tes participations constructives,

[wiwaxia]

Et, non, cube(x) n'est pas dispo.

J'ai effectivement confondu avec la fonction racine cubique.

Je viens de vérifier que Virtual Pascal accepte des instructions comme:

Code :

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

r:= Cuberoot(0.008856); CONST N = 1/3;

moyennant, pour la première, l'appel de l'unité Math.

Quant au passage cité:

Code :

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

1
2
3
4
5
6
7
#define LABF(t)	\
	((t >= 8.85645167903563082e-3) ? \
	pow(t,0.333333333333333) : (841.0/108.0)*(t) + (4.0/29.0))
 
#define LABINVF(t)	\
	((t >= 0.206896551724137931) ? \
	((t)*(t)*(t)) : (108.0/841.0)*((t) - (4.0/29.0)))

c'est vraiment du travail bâclé ; les règles du forum m'interdisent (malheureusement) de lâcher la bride à ma grossièreté naturelle.
Passons sur la précision extravagante; il aurait pu au moins coder:

Code :

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

1
2
pow(t, 1/3) ...
((t*t)*t) ...

et introduire les constantes (je ne connais pas la syntaxe)

Code :

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

Ca = 108/841 ; Cb = 4/29

pour ne pas avoir à recalculer les coefficients de la fonction lors de l'appel de cette dernière.

... sinon il faudra attendre que je gère les couleurs impossibles ...

Là, c'est inquiétant pourquoi pas la quadrature du cercle, ou le mouvement perpétuel ? Tu risques d'y consacrer beaucoup de temps ... As-tu déjà vu un bleu pur aveuglant ?

[Jipété]

Je viens de vérifier que Virtual Pascal accepte des instructions comme:

Code pascal :

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

r:= Cuberoot(0.008856); CONST N = 1/3;

moyennant, pour la première, l'appel de l'unité Math.

Mais Lazarus s'appuie sur FreePascal (récemment mis à jour à la dernière 3.0.4 : toujours maintenu, le truc !), qui ne connaît pas ça. Bah...

Quant au passage cité:

Code C :

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

1
2
3
4
5
6
7
#define LABF(t)	\
	((t >= 8.85645167903563082e-3) ? \
	pow(t,0.333333333333333) : (841.0/108.0)*(t) + (4.0/29.0))
 
#define LABINVF(t)	\
	((t >= 0.206896551724137931) ? \
	((t)*(t)*(t)) : (108.0/841.0)*((t) - (4.0/29.0)))

c'est vraiment du travail bâclé ;

et introduire les constantes (je ne connais pas la syntaxe)

Code pascal :

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

Ca = 108/841 ; Cb = 4/29

pour ne pas avoir à recalculer les coefficients de la fonction lors de l'appel de cette dernière.

Oui, c'est ce que je fais, et avec des noms je te dis pas ! :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
12
const
  PIsurCENTQUATREVINGT = pi / 180;
  SEIZEsurCENTSEIZE = 16.0 / 116.0; // ou 4.0 / 29.0   = 0.137931034
  ZEROZEROQUATREVINGTHUITCINQUANTESIX =  216.0 / 24389.0; // 6^3/29^3 0.00885645 "e" chez bl
  ZEROZEROTRENTEETUNTROISCENTHUIT = 0.0031306684425005883; // pg
  UNsurDEUXPOINTQUATRE = 1 / 2.4;  // 0,416666666667
  NEUFCENTTROISPOINTTROIS = 24389.0 / 27.0; // 29^3/3^3 903,2962963  "k" chez bl
  DIVNEUFCENTTROISPOINTTROIS = 0.00110706;
  SEPTPOINTSEPTCENTQUATREVINGTSEPT = 841.0 / 108.0; // 7,787037037
  //       108 / 841 = 0,128418549346
  // 1 / 7.787037037 = 0,128418549347
  DIVSEPTPOINTSEPTCENTQUATREVINGTSEPT = 108.0 / 841.0;

Là, c'est inquiétant pourquoi pas la quadrature du cercle, ou le mouvement perpétuel ? Tu risques d'y consacrer beaucoup de temps ... As-tu déjà vu un bleu pur aveuglant ?

Oui, je sais bien que je risque de m'aventurer dans des sables mouvants sans fond...
Ou je me résigne à continuer avec le clamping, qui ne fonctionne pas si mal, tous comptes faits, et toute honte bue.