Discussion :

[Guesset]

Bonjour,

Pour illustrer les tris de palettes (et leur intérêt éventuelle dans une recherche rapide) le petit programme prend une palette originale (haut-gauche, standard ? ou aléatoire) et en propose des versions triés : par luminance (haut-droite), par HLS (bas-gauche) et par code entrelacé (bas-droite).

Pour des questions de place les 256 couleurs sont présentées comme dans une page d'écriture : ainsi la dernière d'une ligne côtoie la première de la ligne suivante.

Ce qui paraît intéressant est qu'il émane toujours une certaine douceur de la palette ayant la meilleure distance moyenne entre couleurs consécutives et le plus faible écart type (sauts plus faibles donc bande passante plus faible).

Le programme Lazarus, qui ne fait que cela, est bien sûr disponible.

Salutations

[BBouille]

Wouaw que c'est beau tout ça.
J'essaie de tout comprendre et de réaliser la même chose.
Je suis toujours en train de me battre avec les valeurs obtenues en TSV car je pense qu'il faut passer par là.
Arrondir les valeurs RGB au multiple près de 64 nous écarte des valeurs à retenir, on les simplifie trop il me semble.
Aurais-tu un lien pour convertir les valeurs TSV en RGB car j'obtiens un décalage de valeurs avec les différentes méthodes que j'ai pu trouver?
Pour ceux qui découvrent ce domaine, la seule méthode RGB vers TSV correcte que j'ai pu trouver est celle de Wikipedia https://fr.wikipedia.org/wiki/Teinte_Saturation_Valeur
Mais dans l'autre sens je n'obtiens pas les mêmes valeurs que celles trouvées dans les conversions en ligne.

[Guesset]

Bonjour,

Le fait que la transformation inverse ne redonne pas nécessairement les valeurs d'origine est toujours surprenant mais pas nécessairement illégitime. Par exemple si on met une saturation S très forte et une valeur V également élevée cela peut s'avérer incompatible. Par exemple la valeur la plus forte supposerait du blanc ce qui n'est pas compatible avec une saturation non nulle. L'algorithme fait donc ce qu'il peut mais cela ne correspond pas nécessairement aux valeurs de consigne. On ne s'aperçoit réellement de cela qu'au moment de transformation inverse.

Autre manière de voir les choses. HLS et TSV utilisent un angle pour la teinte. Il y a nécessairement des ajustements plus ou moins douloureux pour faire correspondre un cylindre ou (double) cône avec le cube RGB.

Salutations

[Guesset]

Bonjour,

TSV semble la simple traduction de HSL (pourquoi V ?)

J'utilise ç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
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
type
   TxColor = packed record                       // Idem TColor avec accès facile aux
      case Integer of                            // composantes.
         0 : (Color : TColor);
         1 : (R, G, B, Z : byte);
         end;
   PxColor = ^TxColor;
 
// Conversion HLS -> Color___________________________________________________________________TCOLOR
function ColorOfHLS(H, L, S : integer): TColor;
var
   K : PxColor;
   Cmax, Cmin:  integer;
   function Value(Hue:  integer):  integer;
   begin
      Hue := Hue mod 360;
      if Hue <  0 then Inc(Hue, 360);
      case Hue of
           0..59 : Result := Cmax + ((Cmin-Cmax)*Hue) div 60;
          60..179: Result := Cmin;
         180..239: Result := Cmax + ((Cmin-Cmax)*(240-Hue)) div 60;
             else  Result := Cmax;
      end;
   end;
begin
   K := @Result;
   if L <= 128 then Cmin := L + (S * L) >> 8
               else Cmin := L + (S * (256-L)) >> 8;
   Cmax := 2*L - Cmin;
   if S = 0
   then begin K.R := L;               K.G := L;         K.B := L;             end
   else begin K.R := Value(H + 120);  K.G := Value(H);  K.B := Value(H - 120) end;
end;
 
// Conversion Color -> HLS___________________________________________________________________TCOLOR
procedure ColorToHLS(const C : TColor; var H, L, S : integer);
var
   k : PxColor;
   Delta, Cmax, Cmin : Integer;
begin
   K := @C;
   if K.R > K.G then begin Cmax := K.R; Cmin := K.G; end
                else begin Cmax := K.G; Cmin := K.R; end;
   if K.B > Cmax then Cmax := K.B else if K.B < Cmin then Cmin := K.B;
   L := (Cmax + Cmin) shr 1;
   if Cmax = Cmin then begin  S := 0;  H := 0; end
   else begin
      Delta := Cmax - Cmin;
      if L <= 128 then S := (Delta shl 8 - 1) div (Cmax + Cmin)
      else S := (Delta shl 8) div (512 - (Cmax + Cmin));
      if K.R = Cmax then H := (60*(K.G-K.B) + Delta shr 1) div Delta
      else if K.G = Cmax then H := 120 + (60*(K.B-K.R) + Delta shr 1) div Delta
                         else H := 240 + (60*(K.R-K.G) + Delta shr 1) div Delta;
      if H < 0 then Inc(H, 360);
   end;
end;

Ce code est assez ancien et je devrais peut être le revoir. Attention il est en mode Delphi. En mode Lazarus natif il va demander (plaintivement) de mettre des ^ après chaque K.

Saluations

[tbc92]

Moi je connaissais TSL

Si on est en RGB, il y a un piège à éviter.
on veut découper l'intervalle [0,255] en 4 sous intervalles par exemple.
A priori, On va prendre les 4 valeurs 0, 85 , 170 et 255, et on va dire : pour chaque nombre, on le remplace par la valeur la plus proche, parmi (0,85,170,255).
En faisant comme ça, on a 43 nombres qui sont remplacés par 0, 43 autres qui sont remplacés par 255, et 85 nombres qui deviennent 85, et 85 autres qui deviennent 170.
Les intervalles aux extrémités deviennent des demi intervalles.
Il y a trop peu de nombres qui deviennent soit 0, soit 255.
Si on veut 4 valeurs, avec des intervalles de même longueur, les intervalles doivent tous avoir une longueur de 64,
- les nombres entre 0 et 63 sont ramenés à 0
- les nombres entre 64 et 127 deviennent 96 (la valeur au milieu entre 64 et 127)
- les nombres entre 128 et 192 deviennent 160
- et les nombres au delà de 192 deviennent 255

[Jipété]

(pourquoi V ?)

Parce que c'est le bronx !
https://fr.wikipedia.org/wiki/Teinte_Saturation_Valeur

[BBouille]

Merci Guesset je va voir ça d'autant plus que Delphi est mon langage préféré.
Le modèle TSV pour Teinte Saturation Valeur (en anglais HSV pour Hue Saturation Value ou HSB pour Hue Saturation Brightness)
Le modèle TSL pour Teinte Saturation Luminosité (en anglais HSL pour hue saturation lightness) mais c'est pareil je pense.
Jipété Tu as du boulot avec l'analphabétisme actuel. J'essaie de faire des efforts d'un point de vue langue française et surtout de paraître sympathique, chose la plus importante pour moi. Si ce n'est pas le cas j'espère qu'on me le fera remarquer.

[BBouille]

De retour les amis, je ne lâche pas!
Je suis passé par "toutes les couleurs" mais rien à faire, quelques que soient les distances de couleur, HSV, LAB, ... impossible de trouver la couleur la plus proche de la cible.
Quand je dis impossible, la plupart des pixels trouvent leur couleur la plus proche dans la palette mais il y a toujours des exceptions, je dirais qu'en gros c'est autour des couleurs grisâtres (brunâtres, orangeâtres, verdâtres, ...) qui virent au gris.
Pour résumer je procède comme suit:
1. À partir de la palette de 125 couleurs RGB dont on a parlé précédemment j'ai créé une Palette HSV, XYZ et LAB.
2. Pour chaque pixel on passe du mode RGB en XYZ puis LAB.
3. On calcule la distance de la couleur de chaque pixel à chacune des couleurs de la palette et on retient la plus proche.
Et c'est là que ça coince pourtant j'ai fait des centaines de comparaisons avec des sites qui convertissent les couleurs ou qui calculent les distances LAB, HSV, ... et les résultats sont identiques.
Donc je vais continuer à chercher et améliorer.
Pour ceux que ça intéresse je vais joindre les procédures de conversion principales et surtout celle du calcul de distances LAB où j'ai ramé avant de trouver les "bonnes" valeurs.

[BBouille]

Voici la procédure du calcul de la distance entre couleurs LAB.
Désolé elle est écrite en Xojo (RealBasic, VB6) car tant que je n'aurai pas trouvé la clef je ne la transcrirai pas en Delphi.
Mais si on peut lire ça on peut tout lire.

D'où je suis parti avec des modifications glanées çà et là : https://en.wikipedia.org/wiki/Color_difference

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
Subroutine DISTANCE_CIEDE2000_LAB( cLAB1 As t_LAB, cLAB2 As t_LAB ) Double
  Dim Dist As Double
  Dim DE As Double
  Dim L1, a1, b1, L2, a2, b2 As Double
  Dim kL, kC, kH As Double
  Dim K1, K2 As Double
  Dim SL, SC, SH As Double
  Dim ap1, ap2, bp1, bp2 As Double
  Dim C, C1, C2, Cp, Cp1, Cp2 As Double
  Dim G As Double
  Dim Lp, Hp As Double
  Dim hp1, hp2 As Double
  Dim DLp, DCp, Dhp, DGHp As Double
  Dim DTheta, RC, RT As Double
  Dim T, F As Double
  Dim cLAB As t_LAB
 
  kL = 1
  kC = 1
  kH = 1
 
  K1 = 0.045
  K2 = 0.015
 
  L1 = cLAB1.L
  a1 = cLAB1.A
  b1 = cLAB1.B
 
  bp1 = b1
 
  L2 = cLAB2.L
  a2= cLAB2.A
  b2 = cLAB2.B
 
  bp2 = b2
 
  C1 = Sqrt( a1^2 + b1^2 )
  C2 = Sqrt( a2^2 + b2^2 )
 
  DLp = L2 - L1
  Lp = (L1+L2)/2
  C = (C1+C2)/2
 
  G = (1/2)*( 1 - Sqrt( (C^7)/(C^7+25^7) ) )
 
  ap1 = a1*( 1 + G ) 
  ap2 = a2*( 1 + G )
 
  Cp1 = Sqrt( ap1^2 + b1^2)
  Cp2 = Sqrt( ap2^2 + b2^2)
 
  Cp = (Cp1+Cp2)/2
  DCp = Abs(Cp2 - Cp1)
 
  if bp1 > 0 Then
    hp1 = aTan2(bp1, ap1)*180/Pi
  else
    hp1 = aTan2(bp1, ap1)*180/Pi + 360
  end if
  if bp2 > 0 Then
    hp2 = aTan2(bp2, ap2)*180/Pi
  else
    hp2 = aTan2(bp2, ap2)*180/Pi + 360
  end if
 
  if Abs(hp1 - hp2) > 180 Then
    Hp = (hp1 + hp2 - 360)/2
  else
    Hp = (hp1 + hp2)/2
  end if
 
  T = 1 - 0.17*Cos( (Hp - 30)*Pi/180 ) + 0.24*Cos( 2*Hp*Pi/180 ) + 0.32*Cos( (3*Hp + 6)*Pi/180 ) - 0.2*Cos( (4*Hp - 63)*Pi/180 )
 
  if Abs(hp2 - hp1) <= 180 Then
    Dhp = Abs(hp2 - hp1)
  elseif hp2 - hp1 > 180 AND hp2 <= hp1 Then
    Dhp = hp2 - hp1 + 360
  else
    Dhp = hp2 - hp1 - 360
  end if
 
  DGHp = 2*Sqrt(Cp1*Cp2)*Sin(Pi*Dhp/180/2)
 
  SL = 1 + 0.015*( (Lp - 50)^2 ) / Sqrt( 20 + (Lp - 50)^2 )
  SC = 1 + 0.045*Cp
  SH = 1 + 0.015*Cp*T
 
  DTheta = 30*Exp( -((Hp - 275)/25)^2 )  // !!! 60° dans Wikipedia!
  RC = 2*Sqrt( (Cp^7)/ (Cp^7 + 25^7) )
  RT = -Sin( 2*DTHeta*Pi/180 )*RC
 
  DE = Sqrt( (DLp/(kL*SL))^2 + (DCp/(kC*SC))^2 + (DGHp/(kH*SH))^2 + RT*(DCp/(kC*SC))*DGHp/(kH*SH) )
 
  Dist = DE
 
  Return Dist
 
EndSub

[BBouille]

Procédure RGB vers XYZ.

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
Procedure RGB_TO_XYZ( cRGB As t_RGB ) t_XYZ
 
  Dim sR, sG, sB As Byte
  Dim var_R, var_G, var_B As Double
  Dim X, Y, Z As Double
  Dim cXYZ As t_XYZ
 
  sR = cRGB.R
  sG = cRGB.G
  sB = cRGB.B
 
  var_R = ( sR / 255 )
  var_G = ( sG / 255 )
  var_B = ( sB / 255 )
 
  if var_R > 0.04045 Then
    var_R = ( ( var_R + 0.055 ) / 1.055 ) ^ 2.4
  else
    var_R = var_R / 12.92
  end if
  if var_G > 0.04045 Then
    var_G = ( ( var_G + 0.055 ) / 1.055 ) ^ 2.4
  else
    var_G = var_G / 12.92
  end if
  if var_B > 0.04045 Then
    var_B = ( ( var_B + 0.055 ) / 1.055 ) ^ 2.4
  else
    var_B = var_B / 12.92
  end if
 
  var_R = var_R * 100
  var_G = var_G * 100
  var_B = var_B * 100
 
  X = var_R * 0.4124 + var_G * 0.3576 + var_B * 0.1805
  Y = var_R * 0.2126 + var_G * 0.7152 + var_B * 0.0722
  Z = var_R * 0.0193 + var_G * 0.1192 + var_B * 0.9505
 
  cXYZ = New t_XYZ
 
  cXYZ.X = X
  cXYZ.Y = Y
  cXYZ.Z = Z
 
  Return cXYZ
 
End Sub

[BBouille]

Procédure RGB vers HSV.

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
Procedure RGB_TO_HSV( cRGB As t_RGB ) t_HSV
  Dim CMax, CMin, Delta As Double
  Dim R, G, B As Double
  Dim H, S, V As Double
  Dim cHSV As t_HSV
 
  R = cRGB.R
  G = cRGB.G
  B = cRGB.B
 
  H = 0
  CMin = Min( Min( R, G), B )
  CMax = Max( Max( R, G ), B )
 
  // Calculate luminosity.
  Delta = Cmax - Cmin
 
  V = CMax
 
  if CMax <> 0 Then
    S = 255 * Delta / CMax
  else
    S = 0
  end if
  if S <> 0 Then
    if R = CMax Then
      H = (G - B) / Delta
    elseif G = CMax Then
      H = 2 + (B - R) / Delta
    else
      // B = CMax
      H = 4 + (R - G) / Delta
    end if
 
  else
    H = -1
  end if
  H = H * 60
  if H < 0 Then H = H + 360
 
  H = H           // Hue -> 0..360
  S = S * 100 / 255  // Saturation -> 0..100 %
  V = V * 100 / 255  // Value - > 0..100 %
 
  cHSV = New t_HSV
 
  cHSV.H = ROUND_DECIMALS( H, 0 )
  cHSV.S = ROUND_DECIMALS( S, 1 )
  cHSV.V = ROUND_DECIMALS( V, 1)
 
  Return cHSV
EndSub

[BBouille]

Procédure LAB vers XYZ.

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
Procedure LAB_TO_XYZ( cLAB As t_LAB ) t_XYZ  
  Dim ref_X, ref_Y, ref_Z As Double
  Dim var_X, var_Y, var_Z As Double
  Dim L, A, B As Double
  Dim X, Y, Z As Double
  Dim cXYZ As t_XYZ
 
  // XYZ (Tristimulus) Reference values of a perfect reflecting diffuser
  ref_X =  95.047  // D65 - http://www.easyrgb.com/en/math.php
  ref_Y = 100.000
  ref_Z = 108.883
 
  L = cLAB.L
  A = cLAB.A
  B = cLAB.B
 
  var_Y = ( L + 16 ) / 116
  var_X = A / 500 + Var_Y
  var_Z = Var_Y - B / 200
 
  if var_Y^3 > 0.008856 Then
    var_Y = var_Y ^ 3
  else
    var_Y = ( var_Y - 16 / 116 ) / 7.787
  end if
  if var_X^3 > 0.008856 Then
    var_X = var_X ^ 3
  else
    var_X = ( var_X - 16 / 116 ) / 7.787
  end if
  if var_Z^3 > 0.008856 Then
    var_Z = var_Z ^ 3
  else
    var_Z = ( var_Z - 16 / 116 ) / 7.787
  end if
 
  X = Var_X * ref_X
  Y = Var_Y * ref_Y
  Z = Var_Z * ref_Z
 
  cXYZ = New t_XYZ
 
  cXYZ.X = X
  cXYZ.Y = Y
  cXYZ.Z = Z
 
  Return cXYZ
EndSub

[BBouille]

Procédure XYZ vers LAB.

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
Procédure XYZ_TO_LAB( XYZ As t_XYZ ) t_LAB  
  Dim ref_X, ref_Y, ref_Z As Double
  Dim var_X, var_Y, var_Z As Double
  Dim X, Y, Z As Double
  Dim LAB As t_LAB
  Dim CIE_L, CIE_a, CIE_b As Double
 
  ref_X =  95.047  // D65 - http://www.easyrgb.com/en/math.php
  ref_Y = 100.000
  ref_Z = 108.883
 
  X = XYZ.x
  Y = XYZ.y
  Z = XYZ.z
 
  var_X = X / Ref_X
  var_Y = Y / Ref_Y
  var_Z = Z / Ref_Z
 
  if var_X > 0.008856 Then
    var_X = var_X ^ ( 1/3 )
  else
    var_X = ( 7.787 * var_X ) + ( 16 / 116 )
  end if
  if var_Y > 0.008856 Then
    var_Y = var_Y ^ ( 1/3 )
  else
    var_Y = ( 7.787 * var_Y ) + ( 16 / 116 )
  end if
  if var_Z > 0.008856 Then
    var_Z = var_Z ^ ( 1/3 )
  else
    var_Z = ( 7.787 * var_Z ) + ( 16 / 116 )
  end if
 
  CIE_L = ( 116 * var_Y ) - 16
  CIE_a = 500 * ( var_X - var_Y )
  CIE_b = 200 * ( var_Y - var_Z )
 
  LAB = New t_LAB
 
  LAB.L = CIE_L
  LAB.A = CIE_a
  LAB.B = CIE_b
 
  Return LAB
EndSub

[BBouille]

Procédure XYZ vers RGB.

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
Procedure XYZ_TO_RGB( cXYZ As t_XYZ ) t_RGB  
  Dim var_X, var_Y, var_Z As Double
  Dim var_R, var_G, var_B As Double
  Dim X, Y, Z As Double
  Dim sR, sG, sB As Double
  Dim cRGB As t_RGB
 
  X = cXYZ.X
  Y = cXYZ.Y
  Z = cXYZ.Z
 
  var_X = ( X / 100 ) 
  var_Y = ( Y / 100 )
  var_Z = ( Z / 100 )
 
  var_R = var_X * 3.2406 + var_Y * (-1.5372) + var_Z * (-0.4986)
  var_G = var_X * (-0.9689) + var_Y * 1.8758 + var_Z * 0.0415
  var_B = var_X * 0.0557 + var_Y * (-0.2040) + var_Z * 1.0570
 
  if var_R > 0.0031308 Then
    var_R = 1.055 * ( var_R ^ ( 1 / 2.4 ) ) - 0.055
  else
    var_R = 12.92 * var_R
  end if
  if var_G > 0.0031308 Then
    var_G = 1.055 * ( var_G ^ ( 1 / 2.4 ) ) - 0.055
  else
    var_G = 12.92 * var_G
  end if
  if var_B > 0.0031308 Then
    var_B = 1.055 * ( var_B ^ ( 1 / 2.4 ) ) - 0.055
  else
    var_B = 12.92 * var_B
  end if
 
  sR = var_R * 255
  sG = var_G * 255
  sB = var_B * 255
 
  cRGB = New t_RGB
 
  cRGB.R = Round( sR )
  cRGB.G = Round( sG )
  cRGB.B = Round( sB )
 
  Return cRGB
EndSub

[Jipété]

Bonjour,

je ne suis pas sûr d'avoir tout compris ni de voir où tu veux en venir, alors je me permets d'intervenir aujourd'hui pour te présenter un gag qui va te donner envie de tout passer par la fenêtre et d'aller à la pêche ou au ciné ou où tu veux mais ailleurs loin de tout ça, regarde l'image ci-dessous, lance ton ColorPicker préféré et passe la souris sur le carré noté A, regarde la valeur puis sur le B et compare : tu vois le boulot de compensations à ton insu de ton cerveau ?


Quand on a attaqué cette histoire de contraste le plus fort (= lisibilité max) entre la couleur de la police et la couleur du fond sur lequel elle est présentée, on s'est rendu compte qu'au seuil de basculement certains couples couleur police / couleur fond fonctionnaient très bien, et d'autres pas du tout.
C'est comme ça et on ne peut rien y faire.

Courage et bon week-end,

[BBouille]

Évidemment si tu pars d'un cas qui est une illusion d'optique (L’échiquier d’Adelson), https://www.buzzwebzine.fr/top-5-des...a-redecouvrir/
ce n'est pas ça qui va faire avancer le schmilblick.
Les 2 gris sont rigoureusement les mêmes mais l'ombre nous trompe.

[Jipété]

Évidemment si tu pars d'un cas qui est une illusion d'optique (L’échiquier d’Adelson), https://www.buzzwebzine.fr/top-5-des...a-redecouvrir/

C'était surtout pour montrer à quel point notre cerveau adapte des trucs à sa sauce !

(petite digression)
Et merci pour ce lien, qui m'a permis d'y découvrir une énorme erreur : l'illusion des lignes droites qui ondulent est fausse, les lignes sont VRAIMENT ondulées !
Pour m'en convaincre, j'ai pris l'image et lui ai rajoutée une ligne rouge transparente tirée au cordeau avec un outil de sélection rectangulaire, et le résultat est sans appel : les lignes dites droites ondulent dès le départ...


Ceux et celles qui ne sont pas encore convaincus prendront l'interface d'un outil quelconque (par exemple le bloc-notes) et promèneront sa fenêtre sur l'image en essayant d'aligner le haut ou le bas de l'outil avec n'importe quelle ligne de "l'illusion" : c'est mission impossible !


À comparer avec l'image de ce lien, où tout est bien horizontal, malgré les apparences.
(fin de la petite digression)

[BBouille]

Bien sûr les couleurs sont subjectives mais avec le calcul des distances avec ce qui semble être le dernier progrès dans le domaine le CIEDE2000 je pensais pouvoir aboutir mais malheureusement une couleur trop claire sera considérée comme du blanc, d'autres comme du gris, ...
Alors on pose des conditions, ça marche pour ces couleurs mais plus pour d'autres alors c'est ça que je cherche.

[anapurna]

salut

en faisant un recherche sur ciede2000 on trouve cela
trzduction de ceci

[Guesset]

Bonjour Jipété,

...(petite digression)
Et merci pour ce lien, qui m'a permis d'y découvrir une énorme erreur : l'illusion des lignes droites qui ondulent est fausse, les lignes sont VRAIMENT ondulées !
Pour m'en convaincre, j'ai pris l'image et lui ai rajoutée une ligne rouge transparente tirée au cordeau avec un outil de sélection rectangulaire, et le résultat est sans appel : les lignes dites droites ondulent dès le départ...

En fait, hormis la qualité limitée de cette image, les traits sont droits mais ne sont pas horizontaux. Il suffit de passer dans un éditeur graphique et de tracer un segment qui commence sur une frontière gauche et se termine sur son équivalent à droite. La droite tracée se confond avec la ligne apparemment ondulée.

Salut