Discussion :

[Jipété]

Bonsoir,

Désolé pour le retard à répondre, je n'ai pas reçu les mails comme quoi il y avait du neuf ici...

Le document est tout à fait explicite: Pièce jointe 334481
il intervient une procédure (ou fonction) de ré-haussement des couleurs à l'aide d'une relation linéaire par morceaux :

Ah ben vi, ça va tout de suite mieux en le disant,
Bon, je te taquine, j'ai vu avec plaisir que tu appréciais mon clamp, tu en retrouveras bientôt... Surprise...

Tu peux éventuellement regarder ce que donne la modulation de la pente (k) sur la branche inclinée, et de l'abscisse (m) du premier point de raccordement - données introduites ici en paramètres.
Il faut simplement que soit vérifiée la condition: k * (255 - m) > 255 .

Ouais ouais, dès que j'ai 5 minutes, je m'attaque à un 'toshop-like,

Nan, sans déc', laisse-moi finir mes dégradés LCh° / L*a*b*, je tiens le bon bout, ensuite je remonte ça dans les couleurs contrastées, voir ce que ça donne (ne pas perdre le fil !), et après, promis, j'essaye de trafiquer des images avec l'idée de cette copie d'écran (je m'étais déjà fait un correcteur basique, en trifouillant avec R, G et B mais au plus je lis des trucs au plus je trouve que c'est à ch...)

À pluche,

[Jipété]

Bon voilà,

c'est Noël avant l'heure !

Avec le bout de code en bas de ce post, vous pourrez réaliser la partie gauche de cette image :


Image dans laquelle les dégradés ne mettent pas en valeur l'esthétique des espaces de couleur LCh° (en haut) et L*a*b* (en bas), dommage...

Je pourrais (avec un "s", on est bien au conditionnel) envisager de flouter le résultat, ça fonctionne bien (sauf les bords haut et droit -- effets de bord du floutage) :


mais si quelqu'un a une autre idée, je la lirai avec plaisir.

Ah, 45 millisec. pour afficher tout ça sur ma vieille machine et sans aucune optimisation des constantes. Et chez vous ?

Code Pascal :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
{
Petite unité provenant de la traduction en Pascal d'un code en Csharp
trouvé là https://www.codeproject.com/Articles/19045/Manipulating-colors-in-NET-Part
 
et permettant de convertir des données RGB (par ex. des positions de curseurs 0..255)
vers l'espace de couleurs CIE-L*a*b*, et dans l'autre sens des données CIE-L*a*b*
(encore des curseurs, 0--100 pour L, -128+127 por a et b) vers tout système d'affichage
supportant TColor (facilement adaptable pour utiliser R, G, B).
 
J'ai rajouté la prise en charge du modèle LCh° (0..100 2 fois et 0--360°)
 
jipété, décembre 2017 [ donc joyeux Noël ;-) ]
}
 
unit unit4lablch;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  LCLIntf, LCLType, Math, Classes, SysUtils, Graphics;
 
type
  BASERGB = record
    R : int64;
    G : int64;
    B : int64;
  end;
  TBASERGB = BASERGB;
 
  BASEXYZ = record
    X : double;
    Y : double;
    Z : double;
  end;
  TBASEXYZ = BASEXYZ;
 
  BASELAB = record
    L : double;
    a : double;
    b : double;
  end;
  TBASELAB = BASELAB;
 
  BASELCH = record
    L : double;
    C : double;
    h : double;
  end;
  TBASELCH = BASELCH;
 
const
  CIEXYZ_D65_X =  95.047;
  CIEXYZ_D65_Y = 100.000;
  CIEXYZ_D65_Z = 108.883;
 
function RGBtoLab(red,green,blue: integer): TBASELAB;
function LabtoRGB(l,a,b: double; scl: boolean): TColor;
// ajouts jpt ------------------ scl c'est si la cible utilise scanline ou pas
// voir l'exemple d'utilisation en bas de code
function RGBtoLch(red,green,blue: integer): TBASELCH; // non testé ici /!\/!\/!\
function LchtoRGB(l,c,h: double; scl: boolean): TColor;
 
implementation
 
{Pour ceux qui fonceraient sur le code original sans lire les commentaires tout en bas
de la page du site, l'avant-dernier a pour titre "bug in XYZ to RGB"
et nous dit :
    Clinear[1] = -x*0.9692 + y*1.8760 - z*0.0416; // green
    should be
    Clinear[1] = -x*0.9692 + y*1.8760 + z*0.0416; // green
et il se trouve que le code du projet N'a PAS été corrigé (*ici* oui).
 
Donc méfiance avec les copier/coller un peu trop rapides...
 
Les commentaires in english viennent du code d'origine.
 
Par ailleurs, les 5 fonctions ci-dessous (conversion RGB -> LAB / LCh)
N'ont PAS été testées...
 
Plus bas (après les 3 lignes de "////..."),
les 5 fonctions LCh / LAB --> RGB ont été testées, et embarquent
un booléen pour savoir s'il faut inverser ou pas R et B, nécessaire
si l'ihm utilise les fonctions de Scanline pour peindre les surfaces.
}
 
// 2 ajouts pour Delphi7, provenance Graphics.pas de Lazarus
function RGBToColor(R, G, B: Byte): TColor;
begin
  Result := (B shl 16) or (G shl 8) or R;
end;
 
procedure RedGreenBlue(rgb: TColorRef; out Red, Green, Blue: Byte);
begin
  Red   := rgb and $000000ff;
  Green := (rgb shr 8) and $000000ff;
  Blue  := (rgb shr 16) and $000000ff;
end;
 
 
/// ajout pour LCh°
function LABtoLCH(lab: TBASELAB): TBASELCH; // source easyRGB
var
  var_H: double;
begin
  with lab do begin
    var_H := RadToDeg(arctan2(b, a)); // rajouté R2D, trouvé dans ColorMine
    if ( var_H < 0 ) then var_H := var_H +360
    else  if ( var_H >= 360 ) then var_H := var_H - 360;
    result.L := L;
    result.C := sqrt( power(a, 2)+power(b, 2) );
    result.h := var_H;
  end;
end;
 
/// Converts XYZ to CIELab.
function XYZtoLab(xyz: TBASEXYZ): TBASELAB;
  function  Fxyz(t: double): double;
  begin
    if (t > 0.008856)
    then result := Power(t, (1.0/3.0))
    else result := ( (7.787*t) + (16.0/116.0) );
  end;
begin
  with Result do begin
    L := 116.0 *  Fxyz( xyz.y/CIEXYZ_D65_Y ) -16;
    A := 500.0 * (Fxyz( xyz.x/CIEXYZ_D65_X ) - Fxyz( xyz.y/CIEXYZ_D65_Y) );
    B := 200.0 * (Fxyz( xyz.y/CIEXYZ_D65_Y ) - Fxyz( xyz.z/CIEXYZ_D65_Z) );
  end;
end;
 
/// Converts RGB to XYZ (CIE 1931 color space)
function RGBtoXYZ(red,green,blue: integer): TBASEXYZ;
var
  rLinear, gLinear, bLinear: double;
  r, g, b: double;
begin
  // normalize red, green, blue values
  rLinear := red   /255.0;
  gLinear := green /255.0;
  bLinear := blue  /255.0;
 
  // convert to a sRGB form
  if (rLinear > 0.04045)
  then r := Power((rLinear + 0.055)/(1 + 0.055), 2.2)
  else r := (rLinear/12.92);
  if (gLinear > 0.04045)
  then g := Power((gLinear + 0.055)/(1 + 0.055), 2.2)
  else g := (gLinear/12.92);
  if (bLinear > 0.04045)
  then b := Power((bLinear + 0.055)/(1 + 0.055), 2.2)
  else b := (bLinear/12.92);
 
  // converts
  with Result do begin
    X := (r*0.4124 + g*0.3576 + b*0.1805);
    Y := (r*0.2126 + g*0.7152 + b*0.0722);
    Z := (r*0.0193 + g*0.1192 + b*0.9505);
  end;
end;
 
/// GLUE -- Converts RGB to Lab.
function RGBtoLab(red,green,blue: integer): TBASELAB;
begin
  result := XYZtoLab( RGBtoXYZ(red,green,blue) );
end;
 
/// ajout pour LCh°
function RGBtoLch(red,green,blue: integer): TBASELCH;
begin
  result := LABtoLch( XYZtoLab( RGBtoXYZ(red,green,blue) ) );
end;
 
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 
/// Converts XYZ to RGB.
function XYZtoRGB(xyz: TBASEXYZ): TBASERGB;
type
  TClinear = array[0..2] of double;
var
  Clinear: TClinear;
  i: integer;
begin
  with xyz do begin
    // 3 lignes non existantes dans le code d'origine...
    X := X / 100;
    Y := Y / 100;
    Z := Z / 100;
    Clinear[0] :=  x*3.2410 - y*1.5374 - z*0.4986; // red
    Clinear[1] := -x*0.9692 + y*1.8760 + z*0.0416; // green
    Clinear[2] :=  x*0.0556 - y*0.2040 + z*1.0570; // blue
  end;
 
  for i := 0 to 2 do  // Gamma correction
  if ( Clinear[i] <= 0.0031308 )
  then Clinear[i] := Clinear[i] * 12.92
  else Clinear[i] := (1+0.055) * Power(Clinear[i], 1.0/2.4) -0.055;
 
  with Result do begin
    R := round( Clinear[0]*255.0 );
    G := round( Clinear[1]*255.0 );
    B := round( Clinear[2]*255.0 );
  end;
end;
 
/// Converts Lab to XYZ.
function LabtoXYZ(l,a,b: double): TBASEXYZ;
var
  delta, fx,fy,fz: double;
begin
  delta := 6.0/29.0;
  fy := (l+16)/116.0;
  fx := fy + (a/500.0);
  fz := fy - (b/200.0);
 
  with Result do begin
    if fx > delta
    then X := CIEXYZ_D65_X * (fx*fx*fx)
    else X := (fx - 16.0/116.0)*3*delta*delta*CIEXYZ_D65_X;
    if fy > delta
    then Y := CIEXYZ_D65_Y * (fy*fy*fy)
    else Y := (fy - 16.0/116.0)*3*delta*delta*CIEXYZ_D65_Y;
    if fz > delta
    then Z := CIEXYZ_D65_Z * (fz*fz*fz)
    else Z := (fz - 16.0/116.0)*3*delta*delta*CIEXYZ_D65_Z;
  end;
end;
 
/// GLUE -- Converts Lab to RGB.
function LabtoRGB(l,a,b: double; scl: boolean): TColor; //TBASERGB;
  function Clamp(x, mini, maxi: int64): byte;
  begin
    if x < mini then x := mini else if x > maxi then x := maxi;
    result := byte(x);
  end;
var
  rgb: TBASERGB;
begin
  rgb := XYZtoRGB( LabtoXYZ(l,a,b) );
  // Clamping non présent dans le code d'origine
  if scl
  then Result := RGBtoColor(Clamp(rgb.B,0,255), Clamp(rgb.G,0,255), Clamp(rgb.R,0,255))  // inverser R et B
  else Result := RGBtoColor(Clamp(rgb.R,0,255), Clamp(rgb.G,0,255), Clamp(rgb.B,0,255)); // classique
end;
 
/// ajout pour LCh°
function LchtoLab(lch: TBASELCH): TBASELAB; // source easyRGB
begin // CIE-H° range = 0..360° Getreuer précise "D65"
  with lch do begin
    result.L := L;
    result.a := cos(H * PI / 180) * C;
    result.b := sin(H * PI / 180) * C;
  end;
end;
 
/// GLUE -- ajout pour LCh° vers RGB
function LchtoRGB(l,c,h: double; scl: boolean): TColor;
var
  lab: TBASELAB;
  lch: TBASELCH;
  r,g,b: byte;
begin
  lch.L:=l;  lch.C:=c;  lch.h:=h;
  lab := LchtoLab(lch);
  // Pas de demande d'inversion R<>B puisque faite dessous (suite demande ihm)
  RedGreenBlue(LabtoRGB(lab.L,lab.a,lab.b, False), r,g,b);
  if scl
  then Result := RGBtoColor(b,g,r)  // inverser R et B
  else Result := RGBtoColor(r,g,b); // classique
end;
 
end.
 
{exemple d'utilisation :
1 TButton sur une fiche, et 2 TImage : img360x101 et img4lab (256x256),
sans oublier
uses
  unit4lablch;
 
procedure TForm1.Button1Click(Sender: TObject);
type
  TPointeurDeLigneLCH = array[0..359] of TColor;
  pPointeurDeLigneLCH = ^TPointeurDeLigneLCH;
  TPointeurDeLigneLAB = array[0..255] of TColor;
  pPointeurDeLigneLAB = ^TPointeurDeLigneLAB;
var
  PointeurDeLigneLCH: pPointeurDeLigneLCH;
  PointeurDeLigneLAB: pPointeurDeLigneLAB;
  hh,ww: Integer;
  aBmp: TBitmap;
  Delta        :  int64;
  StartTime    :  DWORD;
begin
  StartTime := GetTickCount;
 
  aBmp := TBitmap.Create;
  with aBmp do begin    // 4 LCH  -- image rectangulaire en haut
    try
      //PixelFormat := pf24bit; //!\ Linux
      PixelFormat := pf32bit; //!\ XP
      Width  := 360;
      Height := 101;
 
//      BeginUpdate;  // à commenter pour D7
      for hh := 0 to 100 do begin
//        PointeurDeLigneLCH := pPointeurDeLigneLCH(RawImage.GetLineStart(hh));  // Lazarus
        PointeurDeLigneLCH := pPointeurDeLigneLCH(Scanline[hh]); // Delphi
        for ww := 0 to 359 do
          PointeurDeLigneLCH^[ww] := LCHtoRGB(hh, 50, ww, true);
                                            // L   C  h°  scanline ?
      end;
//      EndUpdate();  // à commenter pour D7
 
      img360x101.Picture.Graphic := aBmp;
    finally
      Free;
    end;
  end;
 
  aBmp := TBitmap.Create;
  with aBmp do begin    // 4 LAB  -- image carrée en bas
    try
      //PixelFormat := pf24bit; //!\ Linux
      PixelFormat := pf32bit; //!\ XP
      Width  := 256;
      Height := 256;
 
//      BeginUpdate;  // à commenter pour D7
      for hh := 0 to 255 do begin
//        PointeurDeLigneLAB := pPointeurDeLigneLAB(RawImage.GetLineStart(hh)); // Lazarus
        PointeurDeLigneLAB := pPointeurDeLigneLAB(Scanline[hh]); // Delphi
        for ww := 0 to 255 do
          PointeurDeLigneLAB^[ww] := LABtoRGB(50, hh-128, ww-128, true);
                                                  //  a   //  b   scanline ?
      end;
//      EndUpdate();  // à commenter pour D7
 
      img4lab.Picture.Graphic := aBmp;
    finally
      Free;
    end;
  end;
 
  Delta := GetTickCount - StartTime;
  Form1.Caption := IntToStr(Delta) + ' ms';
end;
}

Edit du lendemain : testé sous XP, ràs, et cerise sur le gâteau, testé aussi sous Windows2000 et Delphi7, avec les adaptations de code qui vont bien. Minimes, les adaptations, et commentées.
Enjoy,

[Jipété]

Yep !

Le document est tout à fait explicite : Pièce jointe 334481

Et non...
Si tu regardes bien la partie droite, tu remarques deux ronds rouges entourant le curseur noir à gauche et le curseur blanc à droite (je suppose qu'on parle là de sombre et clair) et juste dessous deux zones avec des chiffres : celle de gauche est passée de 127 à 90, ok (même si on ne sait pas dans quel sens ça évolue : ne serait-ce pas de -127 à -90 en assumant un centre à 0 ?), mais celle de droite ? Elle est restée à 127 alors que le curseur a bougé...

Une explication ?

[wiwaxia]

Rien ne t'échappe. Ma mauvaise vue m'a incité à ne pas entrer dans les détails, et à donner un résultat trop simple.



On peut apparemment choisir deux seuils (m₁, m₂), ce qui permet de mieux encadrer l'histogramme de la couleur; la fonction correctrice n'est plus symétrique par rapport à la médiane (255/2 = 127.5) et devrait avoir pour équation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
PROCEDURE RehCoul(M1, M2: Extended; var j: Byte);
  CONST I1 = 0; I2 = 255; Delta = I2 - I1;          // Valeurs à ajuster éventuellement au logiciel
  VAR J1: Byte; x, y, z: Extended;
  BEGIN
    IF (j<M1) THEN J1:= I1
              ELSE IF (j>M2) THEN J1:= I2
                             ELSE BEGIN
                                    x:= (1.0 * j) - M1, y:= M2 - M1; z:= x / y;     // S'assurer que M2 > M1
                                    x:= Delta * z; J1:= Round(x + I1)  
                                  END
   RehCoul:= J1
  END;

_{Tu verras quand tu seras vieux, et qu'il te faudra lire les notes en bas de page ...}

[Jipété]

Rien ne t'échappe.

Merci pour les précisions, stockées dans un dossier pour plus tard.


Bonjour,

des nouvelles :
ça avance bien, très bien même, sauf le point de détail que je vais vous conter de ce pas :
je suis en train de bricoler un color-chooser à base de LCh° avec un curseur de Lightness, un curseur de Chroma, et un curseur de Hue.


À côté des deux premiers, une barre colorée indiquant quelle couleur sera obtenue selon le sens de déplacement du curseur, classique et rien à signaler.

Le souci vient de la barre colorée sise sous le curseur de Hue ; l'image ci-dessous montre l'évolution de la dite barre (présentée verticalement) avec les réglages suivants, de gauche à droite :

Code text :

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

1
2
3
4
 C à  50 et L à  50
 C à  50 et L à 100
 C à 100 et L à 100
 C à 100 et L à  50

(j'avais essayé de vous faire un gif animé, c'est une catastrophe à cause de la palette limitée du gif...)

On voit bien sur ces images que le bleu met bien sa pagaille, effet de bord de la non-gestion des couleurs impossibles, remplacée par le clamping je pense.

La question est : que toucher, que modifier dans la matrice pour atténuer cet effet de "trop de bleu" ?

La matrice c'est ça, extraite du code fourni récemment :

Code pascal :

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

1
2
3
    Clinear[0] :=  x*3.2410 - y*1.5374 - z*0.4986; // red
    Clinear[1] := -x*0.9692 + y*1.8760 + z*0.0416; // green
    Clinear[2] :=  x*0.0556 - y*0.2040 + z*1.0570; // blue

Les "Clinear[x]" deviendront R, G et B après un ch'tit coup de GammaCorrection, commun aux trois canaux.

À partir de là je suis complètement perdu, alors si quelqu'un a une idée, c'est le moment de sauter sur le clavier (l'idée pourrait être l'origine de cette matrice, pourquoi ces nombres-là et pas d'autres ?).

Bon, maintenant, si y a pas moyen, y a pas moyen et faudra s'habituer à travailler avec ça, mais c'est pas agréable .

àpluche, et bon week-end, malgré les catastrophes de ce monde pas bien fini...

[wiwaxia]

... La matrice c'est ça, extraite du code fourni récemment :

Code pascal :

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

1
2
3
    Clinear[0] :=  x*3.2410 - y*1.5374 - z*0.4986; // red
    Clinear[1] := -x*0.9692 + y*1.8760 + z*0.0416; // green
    Clinear[2] :=  x*0.0556 - y*0.2040 + z*1.0570; // blue

Les "Clinear[x]" deviendront R, G et B après un ch'tit coup de GammaCorrection, commun aux trois canaux.

À partir de là je suis complètement perdu ...

Ce sont à peu de choses près les valeurs déjà mentionnées dans un autre document
et citées par toi-même au message #52 ... Es-tu bien sûr de ne pas tourner en rond ?

[Jipété]

Es-tu bien sûr de ne pas tourner en rond ?

C'est possible, c'est possible, mais alors je ne suis pas le seul, et il va être compliqué de créer un color-chooser esthétiquement agréable, exemple avec un composant extrait d'une librairie écrite en Pascal, ici à gauche en mode design, ie zéro code de mon fait :


(source : mbColorLib)

À droite c'est mon code, et tu auras été le déclic qui m'a poussé à revoir ce composant et à le comparer avec mon travail : on se rend bien compte, avec les deux images côte à côte, que si dans le principe c'est pareil, dans la réalisation les courbes ne démarrent pas et n'arrivent pas aux mêmes endroits.

M'en vais creuser son code, moi, car, tu l'as dit,

Ce sont à peu de choses près les valeurs déjà mentionnées dans un autre document
et citées par toi-même au message #52 ...

Tout est dans ce "à peu de choses près",
Ce dont j'ai peur, c'est de revenir ici dans une heure ou deux, avec deux matrices ou deux manières de calculer les gamma corrections et de demander "mais laquelle est la bonne ?"

Tu vois le truc ?

[Jipété]

Alors voilà.

La principale différence se trouve dans le choix de l'illuminant : j'avais choisi D65 2°, et mbColorLib débarque avec

Code pascal :

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

1
2
3
4
const
  // Observer= 2°, Illuminant= D50
  ref_X = 96.422;
  ref_Z = 82.521;

Résultat des courses, si je choisis celui-là dans mes codes, j'arrive au même résultat :


à gauche comme tout-à-l'heure mbColorLib, au centre mon code avec D65, à droite le même code avec D50 et comme ça ne se voit pas bien, j'ai pris cette image de droite, l'ai collée dans un calque que j'ai positionné par-dessus celle de gauche et en jouant avec afficher/masquer le calque, j'ai bien constaté qu'il n'y avait aucune différence à l'œil.
Je précise "à l'œil" car au-delà de l'illuminant, il y a aussi des petites différences au niveau de la matrice LAB2XYZ (par exemple pour générer le rouge) :

Code pascal :

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

1
2
r := ( 3.2406 * x) + (-1.5372 * y) + (-0.4900 * z); // mbColorLib
r := ( 3.2410 * x) + (-1.5374 * y) + (-0.4986 * z); // CodeProject

ainsi qu'au niveau de la conversion des valeurs L*a*b* vers xyz :

Code pascal :

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

1
2
3
4
if y > 0.2069 then y := IntPower(y, 3) else y := (y - 0.138)/7.787; // mbColorLib
if y >= 0.206896551724137931 then y := y*y*y else y := (y - 16.0/116.0) * (108.0 / 841.0); // autres auteurs
                                                       // = 0.13793103   = 0.128418549 et 1 / 7.787 = 0.128419160 
//Note : Intpower returns base to the power exponent, where exponent is an integer value.

À droite toute deux bandes correspondant au début des carrés, la 1^re avec D65 et l'autre avec D50, je les ai inversées par rapport aux grands carrés, on voit mieux la différence.


Bref, qu'est-ce qu'il faut choisir comme illuminant ? C'est la question que j'avais posée il y a qq jours (je devais sentir le loup caché dans le bois...)
J'avais alors décidé D65, dommage, D50 a l'air plus joli, plus harmonieux.

Enfin bon, c'est comme ça.

[wiwaxia]

... Ce dont j'ai peur, c'est de revenir ici dans une heure ou deux, avec deux matrices ou deux manières de calculer les gamma corrections et de demander "mais laquelle est la bonne ?" ...

Aucune.
Le paramétrage est lié à la perception visuelle, qui dépend des conditions d'observation: ce qui compte en dernier recours, c'est ce que voit l'observateur.
Les nuances perçues sont largement affectées par l'éclairage ambiant, l'orientation de l'écran et même les couleurs des zones voisines: alors cesse de te tourmenter sur la confiance à accorder à la 3^me ou à la 4^me décimale.

Tu devrais t'en tenir à un seul standard, celui qui te paraît le plus fiable et le plus reconnu - et ne plus te préoccuper des autres.
Il n'y a rien de mieux pour gâcher un calcul que de partir de données hétérogènes, ou de tenter de les concilier.

... J'avais alors décidé D65, dommage, D50 a l'air plus joli, plus harmonieux ...

Alors tu prends D50 ! C'est tout de même toi qui regardes l'écran, non ?
Et tu n'est pas daltonien ?

[Jipété]

Et tu n'est pas daltonien ?

Non, pas encore, que je sache.

Alors tu prends D50 ! C'est tout de même toi qui regardes l'écran, non ?

Mais je ne serai pas seul à utiliser l'outil final, donc je remets ce que j'avais noté le 9/12 :

Note 2: Almost all systems used today to view Web content assume sRGB encoding. Unless it is known that another color space will be used to process and display the content, authors should evaluate using sRGB colorspace.

Et c'est toi qui m'a donné le lien vers ce texte,

Merci pour tout.

[Jipété]

Bonjour,

je trouvais que mes couleurs opposées n'étaient pas terribles, quand je "remontais" les récentes trouvailles dans les vieux codes.

Au final et pour en avoir le cœur net, je suis parti d'une couleur bien précise,

1. je l'ai faite afficher puis je l'ai convertie en R, G et B ;
2. j'ai pris ces 3 bytes et les ai transformés en LCh avec une des fonctions fournies l'autre jour et notée function RGBtoLch(red,green,blue: integer): TBASELCH; // non testé ici /!\/!\/!\ puis affichage avec LCHtoRGB(L,C,H: double; scl: boolean): TColor;,

et la comparaison des deux affichages montrait bien une différence énorme.

Alors je suis allé fouiller dans la sous-fonction RGBtoXYZ et mystère et boule de gomme mais en comparant avec la même fonction trouvée dans le projet mbColorLib (déjà cité), j'y ai trouvé 3 instructions supplémentaires :

Code pascal :

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

1
2
3
  r := r * 100;
  g := g * 100;
  b := b * 100;

que je me suis empressé de rajouter, et ça a solutionné mon problème de différences de couleurs, ouf !

Donc en gros, pour ceux qui auraient téléchargé mon bazar, la modif consiste à repérer dans la function RGBtoXYZ(red,green,blue: integer): TBASEXYZ; cet endroit :

Code pascal :

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

1
2
3
  else b := (bLinear/12.92);
 
  // converts

et à le remplacer par

Code pascal :

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

1
2
3
4
5
6
7
8
  else b := (bLinear/12.92);
 
  // trouvé dans mbColorLib :
  r := r * 100;
  g := g * 100;
  b := b * 100;
 
  // converts

Et vous pourrez enlever // non testé ici /!\/!\/!\, désolé pour le dérangement et le contre-temps.