Discussion :

[Jipété]

Bonjour,

Il me reste un petit souci avant d'attaquer cette variation du chantier :

L'entier IndiceC est un pilote qui peut prendre l'une des 3 valeurs (1, 2, 3) selon la couleur (Rouge, Vert, ou Bleu) du coin supérieur gauche (Csg); il détermine l'appel de l'une des 3 fonctions qui suivent:

Quid si l'on a un jaune parfait, 255 255 0 ?

[wiwaxia]

Bonjour,

Il me reste un petit souci avant d'attaquer cette variation du chantier :

Citation Envoyé par wiwaxia
L'entier IndiceC est un pilote qui peut prendre l'une des 3 valeurs (1, 2, 3) selon la couleur (Rouge, Vert, ou Bleu) du coin supérieur gauche (Csg); il détermine l'appel de l'une des 3 fonctions qui suivent:

Quid si l'on a un jaune parfait, 255 255 0 ?

Le jaune, complémentaire du bleu, se trouve à l'autre extrémité du grand côté du rectangle; il faut donc choisir (3).

PS: l'un des 3 plans bissecteurs du cube de couleurs, contenant le sommet bleu (IndiceC = 3) et le jaune.
Les 3 sections rectangulaires sont disposées dans l'espace.
Ce schéma négligé fait tache dans un débat où l'on vient d'évoquer l'exigence impérieuse concernant la qualité professionnelle des graphiques, mais je n'ai pas les moyens de faire autrement .

[Jipété]

Bonjour,

j'avais promis d'attaquer ce chantier cette semaine, j'ai tenu ma promesse mais ça n'a pas été glorieux...

Au final je n'arrive à rien car je ne sais pas trop comment "causer" avec ta boîte noire : l'idée aurait été un truc qui renvoie une couleur opposée (ou pas, pour faire plaisir à tbc92 qui n'a pas complètement tort : en prod' deux boutons radio -couleur opposée -couleur ton-sur-ton et hop !) mais je ne sais pas par quel bout prendre ton code, c'est trop compliqué, d'autant plus que j'ai un gros souci sur un autre code très très très chronophage...

Pi sur un autre forum, quelqu'un m'a fait la remarque suivante : quid si r=g=b pour la couleur de fond ? Que doit renvoyer IndiceC dans ce cas ?

Voilà mes interrogations de fin de semaine et donc le mot de la fin (pour aujourd'hui) s'impose : bon week-end,

[sevyc64]

Bon week-end à toi, c'est quand même le plus important.

Il n'y a pas d'urgence car finalement ce n'est pas moi qui ferait cette modification (et probablement qu'elle ne sera désormais pas faite du tout) car je suis maintenant en préavis. Je vais m'en aller martyriser quelques autres codes.

Par contre, je regarderais dans quelques temps, pour intégrer cela dans une petite bibliothèque perso de snippets car ça peut toujours servir.

[wiwaxia]

Salut,

... Au final je n'arrive à rien car je ne sais pas trop comment "causer" avec ta boîte noire ...

Pas très grave, c'est un ensemble d'instructions inséparables, donc pas difficile à manier ... il faut simplement adapter les données introduites au contexte.
Si cela peut te remonter le moral, je viens de perdre un après-midi sur une erreur stupide (elles le sont toutes) de programmation ; il a fallu passer à autre chose, et une nuit réparatrice a permis de tout remettre en ordre en quelques minutes.

... Pis sur un autre forum, quelqu'un m'a fait la remarque suivante : quid si r=g=b pour la couleur de fond ? Que doit renvoyer IndiceC dans ce cas ? ...

La réponse est dans les fonctions discontinues rappelées il y a peu (#117), et qui portent au choix sur l'indice de couleur ou sa luminance:

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
  // Critère (1) - le seuil (Is = 128) peut être modifié
 
IF (Ic<128) THEN Jc:= Ic + 128                    // Ic: indice initial de couleur
            ELSE Jc:= Ic - 128;                   // Jc: nouvel indice
 
  // Critère (2)
 
CONST N = 2.2; N1 = 1 / 2.2;
      Lmax = Power(255, N);      
      Seuil = 0.5 * Lmax;                    // Seuil de luminance modifiable en changeant le premier facteur
      DeltaL = Lmax - Seuil;
...
LumA:= Power(Ic, n);
IF (LumA<Seuil) THEN LumB:= LumA + DeltaL
                ELSE LumB:= LumA - Seuil;                    // L(0) = DeltaL = L(Lmax)
Jc:= Power(LumB, N1)

Exemple d'application du premier critère (portant sur les indices):
# le gris moyen (127, 127,127) donnera le blanc le plus clair (255, 255, 255), tandis que (128, 128, 128) conduira au noir le plus profond (0, 0, 0);
# d'autres points située hors de l'axe chromatique, mais très proches des précédents, conduiront aux couleurs fondamentales:
(127, 128, 128) au rouge (255, 0, 0), (127, 128, 127) au pourpre (255, 0, 255).
Les teintes initiales correspondant toutes à des gris indiscernables, la couleur de contraste est imprévisible et l'on a l'impression que le code adopte un comportement erratique.

Bon week-end.

[wiwaxia]

Bonjour,

Il existe un type de palette bidimensionnelle, dans laquelle les couleurs varient continûment entre celles définies aux quatre coins de la figure (rectangle ou carré, la forme est indifférente).
Les 3 composantes locales (r, v, b) dépendent des coordonnées relatives (x, y) par un polynôme quadratique de la forme:

Code :

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

 z = Ka + Kx*(x - 1/2) + Ky*(y - 1/2) + Kxy*(x - 1/2)*(y - 1/2)

et dont les coefficients s'expriment simplement en fonction des données extrêmes:

Code :

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

1
2
3
4
5
6
7
8
 
Z(0,1) _ _ _ _ _ Z(1,1)
|                |          Ka  = (Z00 + Z11 + Z01 + Z10)/4
|                |          Kx  = (Z11 - Z00 - Z01 + Z10)/4
|                |          Ky  = (Z11 - Z00 + Z01 - Z10)/4
|                |          Kxy = (Z00 + Z11 - Z01 - Z10)/4
|                | 
Z(0,0) _ _ _ _ _ Z(1, 0)

La courbure de la surface obtenue disparaît lorsque coïncident les moyennes des valeurs aux sommets opposés;

Code :

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

Kxy = 0 si (Z00 + Z11) = (Z01 + Z10)

ce que l'on obtient correspond alors à une section plane du domaine cubique des couleurs - à l'exception de la forme réelle du contour (carré, rectangle ou parallélogramme).

Le libre choix des quatre couleurs initiales permet une bonne exploration (bien que restreinte à une surface) des diverses régions du domaine.
La particularité de la quadrique utilisée est de contenir deux faisceaux de droites, les lignes d'équation (x = C^te) ou (y = C^te), de sorte qu'aucune valeur intermédiaire ne sort du domaine défini par les données: [Min(Z00, Z10, Z01, Z11) ; Max(Z00, Z10, Z01, Z11)] .



Certains pourront regretter l'aspect un peu terne de certaines zones intermédiaires; c'est juste, et l'on peut y remédier par un ré-haussement des couleurs en introduisant dans la combinaison linéaire les luminances correspondantes (I_cⁿ) au lieu des indices (I_c). Mais ce n'est pas le sujet, et ce qui sert pour la suite.

[wiwaxia]

Pour répondre avec plus de précision à la question du choix de la couleur présentant le plus grand contraste sur un fond donné, il faut considérer deux paramètres, relatifs à la fonction discontinue nécessairement présente au coeur du programme, et qu'on supposera pour simplifier linéaire par morceaux.

1°) Le seuil de discontinuité: le choix se porte spontanément sur Lim1 = 255/2 = 127.5 ;
mais il se peut que la limite correspondant à une luminosité relative de 50% se révèle plus pertinente, soit: Lim2 = 255/(2^1/n) = 186 (pour n = 2.2) ou 191 (pour n = 2.4);
enfin rien n'empêche, par précaution, d"envisager une valeur intermédiaire, par exemple: Lim3 = 160 .

2°) La pente du graphe de part et d'autre de la discontinuité: on a proposé d'emblée un décalage fixe entre le nouvel
indice de couleur (J_c) et l'ancien (I_c), d'où une pente égale à l'unité: l'ensemble des valeurs de (J_c) couvre alors la totalité de l'intervalle [0 ; 255] ;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 FUNCTION C_Contr00(Px: Pixel): Pixel;  // Lim = 255/(2^(1/n)
   CONST Max = 255; Lim = 160;          // = 186 (n=2.2) … 191 (n=2.4)
         M1L = Max + 1 - Lim;
   VAR i: Byte; p, q: Reel; P_: Pixel;
   BEGIN
     FOR i:= 1 TO 3 DO
       IF Px[i]<Lim THEN P_[i]:= Px[i] + M1L
                    ELSE P_[i]:= Px[i] - Lim;
     C_Contr00:= P_
   END;

cependant une pente plus réduite (par exemple 0.5) permet d'améliorer le contraste sur des fonds relativement sombres, ce que réalise le code suivant:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 FUNCTION C_Contr01(Px: Pixel): Pixel;
   CONST Max = 255; Lim = 160; Min = 79;          // p = 176 , 255
   VAR i, k: Byte; p, q: Reel; P_: Pixel;         // p =   0 ,  47
   BEGIN
     FOR i:= 1 TO 3 DO
       BEGIN
         p:= Px[i] / Lim; q:= Abs(1 - p); k:= Round(Min * q);
         IF (Px[i]<Lim) THEN P_[i]:= Max - k
                        ELSE P_[i]:= k
       END;
     C_Contr01:= P_
   END;

le cas limite d'une pente nulle est le plus simple, la nouvelle couleur obtenue se réduisant à l'une des 8 couleurs fondamentales;

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 FUNCTION C_Contr02(Px: Pixel): Pixel;
   CONST Max = 255; Lim = 160;                    // p = 255 , 255
   VAR i, k: Byte; P_: Pixel;                     // p =   0 ,   0
   BEGIN
     FOR i:= 1 TO 3 DO
       IF (Px[i]<Lim) THEN P_[i]:= Max
                      ELSE P_[i]:= 0;
     C_Contr02:= P_
   END;

# La question des gris intermédiaires (soulevée par Jipété) trouve ici sa réponse, car les résultats ne dépendent plus ici de la pente; ils confirment ce que j'en avais dit (#125 )

Les teintes initiales correspondant toutes à des gris indiscernables, la couleur de contraste est imprévisible

et permettent de mieux cerner la valeur du seuil.
Les images ci-dessous correspondent aux 3 seuils: Lim = (127.5 , 160.5 , 190.5); la diagonale montante appartient à l'axe chromatique et relie les sommets (g, g, g), (g', g', g'), avec g = Lim * 2.5 et g' = Lim + 2.5 = g + 5 :



La limite médiane paraît donner le meilleur contraste ... mais chacun reste libre de son jugement.

# Voici pour le même seuil (Lim = 160) ce qu'on obtient pour les couleurs franches, dans le cas d'une pente (p) égale à 1, 0.5 et 0:
■ p = 1

■ p = 1/2

■ p = 0


C'est dans le dernier cas qu'on obtient le meilleur contraste

[Jipété]

Bonjour,

wiwaxia, je ne te cacherai pas que tu m'as perdu avec tous tes ronds...

Certainement que quelque chose de très intéressant doit se cacher dessous, permettant d'affiner aux petits oignons la formule magique qui permettra de trouver la meilleure couleur en matière de contraste et autres critères, mais je suis largué pour mettre ça "en prod".

Alors j'ai suivi mon petit bonhomme de chemin, et j'en suis là :


en haut à gauche la couleur de fond pour laquelle on cherche la couleur au meilleur contraste,
dessous à gauche un panneau de réglages HSL et à droite son frère TSV, pour l'instant la couleur opposée choisie automatiquement puis ajustée éventuellement ici n'est pas encore répercutée dans le grand rectangle, tout n'est pas fini.

À droite du grand rectangle colorié, le "carré à outils" pour changer le texte et ses taille, police et attributs, une option "ton sur ton" (à venir), un bouton pour lancer un système de capture (pour quand la copine vient avec une photo sur clé uzbe) qui recopiera la zone sélectionnée dans le grand rectangle, et enfin une petite image de la grande plus un choix de différents niveaux de floutage afin d'avoir une moyenne de la grande image la plus moyenne possible, et à partir de là, hop ! 3 fois rien de calculs automatiques et les panneaux du bas s'adaptent, reste plus à la copine qu'à affiner au point près avec les... curseurs !

Ce que j'ai fait pour générer cette image, d'ailleurs : j'ai baissé un poil le L du panneau HSL et le S du STV, ce qui a modifié la couleur du bleu déterminée par l'outil comme opposée à l'orange.

Voili voilou,

PS : ne pas tenir compte du décalage entre le curseur T à droite à 210 et l'indicateur en bas à 213, tout n'est pas fini (un ColorPicker confirme les chiffres des StatusBars).

[Jipété]

Ça avance, ça avance...

Correction de tout un tas de bugs à la noix (glissement de la teinte en jouant avec la saturation, à cause des approximations des erreurs d'arrondis [J. Delmas en parle bien]), ça avance pas trop mal :


wiwaxia tu vas être content : j'ai utilisé ta formule pour la "cassure" du gris, je l'ai appliquée à la saturation en mode "ton sur ton" (mais bon, ça surprend, à l'utilisation )

[wiwaxia]

Bonjour,

... j'ai utilisé ta formule pour la "cassure" du gris, je l'ai appliquée à la saturation en mode "ton sur ton" (mais bon, ça surprend, à l'utilisation )

Je vois que tu as choisi le cas le plus difficile; mais cela doit conduire à des résultats intéressants. En rappel, et à toutes fins utiles, les fragments de code détaillés au #127 (26/02/2017, 20h46)

# pente égale à l'unité: l'ensemble des valeurs de (J_c) couvre alors la totalité de l'intervalle [0 ; 255] ;

Code :

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

1
2
 
 FUNCTION C_Contr00(Px: Pixel): Pixel;

# pente plus réduite (par exemple 0.5)

Code :

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

1
2
 
 FUNCTION C_Contr01(Px: Pixel): Pixel;

# pente nulle: cas le plus simple

Code :

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

1
2
 
 FUNCTION C_Contr02(Px: Pixel): Pixel;

... ainsi que les graphes illustrant les discontinuités, et que je n'ai pas donné par négligence - d'autant que j'ai quelque peu abusé des grandes images, et de la patience des modérateurs


# Pour en revenir à l'une de tes précédentes remarques,

... wiwaxia, je ne te cacherai pas que tu m'as perdu avec tous tes ronds ...

l'abondance des "ronds" ne provient pas d'une obsession maniaque du cercle, mais de ce que mes programmes actuels ne me permettent pas d'insérer du texte dans une image avec toute la liberté souhaitée; je m'en suis donc tenu, faute de temps, à une figure unique facile à coder, et qui constitue un test local du contraste recherché.
Ce que tu vérifies sur 7×16 = 112 cases à coloration aléatoire, je l'obtiens au niveau des 20×20 = 400 petits cercles, et sur une variation progressive de la couleur du fond:



On y décèle ainsi facilement les variations du contraste, et les zones où il apparaît insuffisant.

PS: la connexion a été interrompue, et les documents perdus en cours de route.

[Jipété]

Bonjour,

j'ai trente secondes...

On y décèle ainsi facilement les variations du contraste, et les zones où il apparaît insuffisant.

Certes, certes, cependant on ne m'ôtera pas de l'idée qu'une fonction à qui on passerait une couleur quelconque (sous forme de TColor en Pascal) et qui retournerait la couleur qu'elle calcule comme étant la plus appropriée, rendrait les plus grands services.

Parce qu'en l'état, encore une fois, je ne vois pas par quel bout attraper tes formules pour les utiliser au mieux.

Deux exemples tout simples, et dont les noms sont parlants :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
function RGBtoColor(const R,G,B: Byte): TColor; 
begin
  Result := (B shl 16) or (G shl 8) or R;
end;
 
procedure ColorToRGB(const aColor: TColor; out R,G,B: Byte); 
begin
  R :=  aColor and $FF;
  G := (aColor shr  8) and $FF;
  B := (aColor shr 16) and $FF;
end;

Il nous faudrait un truc du genre

Code pascal :

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

1
2
3
4
5
6
7
function BlackBoxWiwaxia(const inColor: TColor): TColor;
begin
  ColorToRGB(inColor, R,G,B);
  // bosse avec R, G, et B...
  . . .
  Result := RGBtoColor(R,G,B);
end;

[wiwaxia]

Bonjour,

Je réponds rapidement à ton message, trouvé à l'instant.

... cependant on ne m'ôtera pas de l'idée qu'une fonction à qui on passerait une couleur quelconque (sous forme de TColor en Pascal) et qui retournerait la couleur qu'elle calcule comme étant la plus appropriée, rendrait les plus grands services.

Parce qu'en l'état, encore une fois, je ne vois pas par quel bout attraper tes formules pour les utiliser au mieux.

Deux exemples tout simples, et dont les noms sont parlants :
... / ...
Il nous faudrait un truc du genre

Code pascal :

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

1
2
3
4
5
6
7
function BlackBoxWiwaxia(const inColor: TColor): TColor;
begin
  ColorToRGB(inColor, R,G,B);
  // bosse avec R, G, et B...
  . . .
  Result := RGBtoColor(R,G,B);
end;

C'est précisément ce que fait chacune des 3 fonctions proposées au message #127 ; il revient au programmeur de les adapter à son propre langage, et aux outils qui lui sont familiers.
Il n'est pas exclu qu'une fonction ou procédure analogue existe dans l'arsenal de Delphi ou Lazarus: après tout, pourquoi pas ?
Cependant quelqu'un nous l'aurait probablement indiqué depuis le début de cet échange ⁽¹⁾ ... et l'essentiel n'est pas là: il s'agit de bien comprendre le but recherché, et les moyens que l'on se donne pour l'atteindre, et non d'insérer à tout prix la fonction d'un répertoire donné (X) ou (Y)

Code :

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

Pochette_Surprise(c: Type_Pixel): Type_Pixel;

dont on ne connaît pas exactement le comportement.
Une fois cette étape franchie, le code suit naturellement.

De plus, les images proposées ne constituent pas un but en soi, il ne s'agit que de test visuels, qui permettent de juger du bon choix d'une limite, ou d'une fonction; chacun les réalise à sa façon.
Et leur examen a permis, malgré leurs imperfections, d'apporter deux réponses concernant le contraste optimal de couleur:
Lim = 160 pour la frontière de discontinuité, et Lum = 25% pour le basculement du noir au blanc (je reviendrai sur ce dernier point).

(1) 2345 visiteurs au compteur : le record d'il y a un an (2516) serait-il bientôt battu ?

PS: Je viens de découvrir une série d'articles tout récemment parus sur le blog de Gilles Vasseur et qui pourraient t'intéresser indirectement:

Rotation d'une image - bibliothèque BGRABitmap avec Lazarus
https://www.developpez.net/forums/bl...p-lazarus-1-2/
https://www.developpez.net/forums/bl...p-lazarus-2-2/

Redimensionnement d'une image - BGRABitmap avec Lazarus
https://www.developpez.net/forums/bl...itmap-lazarus/

Dessiner des rectangles - BGRABitmap avec Lazarus
https://www.developpez.net/forums/bl...p-lazarus-2-3/
https://www.developpez.net/forums/bl...p-lazarus-1-3/

[wiwaxia]

Bonjour,

Pour revenir au dernier échange, il y a l'affirmation des principes

... il revient au programmeur de les adapter à son propre langage ...

et la question de proposer quelque chose pour sortir de l'enlisement.

... Deux exemples tout simples, et dont les noms sont parlants :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
function RGBtoColor(const R,G,B: Byte): TColor; 
begin
  Result := (B shl 16) or (G shl 8) or R;
end;
 
procedure ColorToRGB(const aColor: TColor; out R,G,B: Byte); 
begin
  R :=  aColor and $FF;
  G := (aColor shr  8) and $FF;
  B := (aColor shr 16) and $FF;
end;

Les noms, oui, mais le contenu: pas du tout ! Et je n'ai pas la capacité d'assimiler Free Pascal et Lazarus en 10 minutes ...

Tentons d'injecter les instructions de la fonction la plus simple, et qui a donné les meilleurs résultats:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 FUNCTION C_Contr02(Px: Pixel): Pixel;
   CONST Max = 255; Lim = 160;                    
   VAR i, k: Byte; P_: Pixel;                     
   BEGIN
     FOR i:= 1 TO 3 DO
       IF (Px[i]<Lim) THEN P_[i]:= Max
                      ELSE P_[i]:= 0;
     C_Contr02:= P_
   END;

dans l'emballage que tu souhaites:

... Il nous faudrait un truc du genre

Code pascal :

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

1
2
3
4
5
6
7
function BlackBoxWiwaxia(const inColor: TColor): TColor;
begin
  ColorToRGB(inColor, R,G,B);
  // bosse avec R, G, et B...
  . . .
  Result := RGBtoColor(R,G,B);
end;

Pourrait-on envisager ceci ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
FUNCTION BlackBox(const inColor: TColor): TColor;
CONST Max = 255; Lim = 160;   
VAR R1, G1, B1: Byte;
BEGIN
  ColorToRGB(inColor, R,G,B);
  IF (R<Lim) THEN R1:= Max ELSE R1:= 0;                    // on peut sans doute abréger en R:= Max ELSE R:= 0; ... etc
  IF (G<Lim) THEN G1:= Max ELSE R1:= 0;
  IF (B<Lim) THEN B1:= Max ELSE R1:= 0;
  R:= R1; G:= G1; B:= B1:
  Result := RGBtoColor(R,G,B);
END;

Il est sans doute possible d'améliorer ces instructions pachydermiques; si cela ne marche pas, demande la traduction correcte sur le forum pascal: le code est suffisamment clair pour que vienne une réponse rapide.

[Jipété]

Bonjour,

C'est rigolo ta réponse, c'est exactement ce à quoi je pensais ce matin

Pourrait-on envisager ceci ?

Mais tout à fait !

Je dirai même plus, dans la mesure où "Max" doit être un mot réservé, qu'on va le remplacer par "Maxi", on peut même déplacer "Lim" en second paramètre de la fonction et donc accessible de l'extérieur (curseur, zone de saisie, etc.), et j'accepte l'abréviation, ce qui donne :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
 
FUNCTION BlackBox(const inColor: TColor; Lim: integer): TColor;
CONST Maxi = 255; 
VAR R, G, B: Byte;
BEGIN
  ColorToRGB(inColor, R,G,B);
  IF (R<Lim) THEN R:= Maxi ELSE R:= 0;
  IF (G<Lim) THEN G:= Maxi ELSE G:= 0;
  IF (B<Lim) THEN B:= Maxi ELSE B:= 0;
  Result := RGBtoColor(R,G,B);
END;

Il est sans doute possible d'améliorer ces instructions pachydermiques;

Meuh non, sont très bien tes instructions, lisibles et tout ; malheureusement, je n'ai pas trop le temps de tester ce matin, mais je promets un retour rapide.

[Jipété]

Bonsoir,

chose promise chose tenue, mais force est de constater, encore une fois, qu'il n'y aura pas de solution universelle et que le curseur de réglages s'impose au graphiste soucieux d'un résultat sympathique...

Je suis donc parti de la formule de ce matin et de mes vieux bouts d'essais, j'ai utilisé un curseur en commençant à 150 (en commençant à 0 tous les textes sont noirs, et certains dont le fond est bien foncé, ont quand même du mal à s'inverser, par exemple col 3 ligne 1 bascule à 14 du curseur alors que 2 1 bascule à 7 )

Bref, j'ai fait des images à 150, 160, 170, 180 et 210 où 2 1 va basculer vers un jaune clair et brillant (255 255 0), et la dernière image est un gif qui reprend les 5 :




Y a des jours, je me demande s'il ne faudrait pas tout repenser (encore que, le plus gros est fait) et envisager de travailler avec un espace de couleurs plus respectueux de la perception visuelle, j'ai nommé CIE L*a*b* (ou L*C*h).

Pi tant qu'à y être faudrait aussi trouver des composants qui bossent en 16 bits, histoire de minimiser les erreurs d'arrondis (déjà constaté des erreurs chez moi, genre T varie quand je trifouille V en mode TSV 8 bits).

Mais c'est probablement un chantier pour une vie future,

[wiwaxia]

Bonjour,

Il se confirme que la limite du meilleur contraste (blanc/noir) sur fond coloré correspond bien à une luminance relative de 25 %, comme cela avait été signalé plus tôt (#132, 02/03/2017, 17h27).
J'ai repris le test sur quelques fonds dégradés, à teintes arbitraires, en y ajoutant le tracé de l'isophote limite, d'équation L = 0.25 .

_ _ _

Le calcul de la luminance relative a été effectué à partir de son expression standard, dont le codage ne présente pas de complication particulière, compte tenu de ce que la correction aux faibles éclairements n'intervient pas.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 FUNCTION LumRvb(Px: Pixel): Reel;
   CONST Coeff: Lst3R = (0.2126, 0.7152, 0.0722);
         h = 14.025; Kl= 1.474E-6;     // h = 255 * 0.055
   VAR i: Byte; p, q, s, t: Reel;      // Kl = (255*1.055)^-2.4
   BEGIN
     s:= 0;
     FOR i:= 1 TO 3 DO BEGIN
                         p:= Power(Px[i] + h, 2.4); q:= Coeff[i] * p;
                         t:= s + q;                 s:= t
                       END;
     LumRvb:= Kl * s
   END;

On a accordé beaucoup trop d'importance (moi le premier) à des simplifications anecdotiques dont l'intérêt apparaît finalement contestable, à part soulager le lecteur tétanisé par les mathématiques .
Une approximation (citée nulle part) est à ce sujet envisageable, mais ce n'est pas le lieu de la développer ici.

Le tracé des graphes d'équiluminance pourrait être amélioré; il résulte ici du balayage systématique des colonnes, et de la détection du changement de signe de l'écart:
E_lum = L(x, y) - 0.25 .

Voilà donc la longue et laborieuse réponse apportée à la question de sevyc64.

# Il faut que je signale ici une rectification qui n'a pas été faite dans les délais (#126 - 26/02/2017), afin d'éviter une perte de temps à qui voudrait reprendre le calcul des dégradés:

Les 3 composantes locales (r, v, b) dépendent des coordonnées relatives (x, y) par un polynôme quadratique de la forme:

Code :

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

 z = Ka + Kx*(x - 1/2) + Ky*(y - 1/2) + Kxy*(x - 1/2)*(y - 1/2)

et dont les coefficients s'expriment simplement en fonction des données extrêmes:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Z(0,1) _ _ _ _ _ Z(1,1)
|                | 
|                |          Ka  = (Z11 + Z00 + Z10 + Z01) * (1/4)
|                |          Kxy = (Z11 + Z00 - Z10 - Z01)
|                | 
|                |          Kx  = (Z11 - Z00 + Z10 - Z01) * (1/2)
|                |          Ky  = (Z11 - Z00 - Z10 + Z01) * (1/2)
|                | 
Z(0,0) _ _ _ _ _ Z(1, 0)

[Jipété]

Bonjour bonjour,

[...] On a accordé beaucoup trop d'importance (moi le premier) à des simplifications anecdotiques dont l'intérêt apparaît finalement contestable, à part soulager le lecteur tétanisé par les mathématiques .

Ah, je me reconnais, là,

Bon, j'avais dit que je me pencherais sur CIE L*a*b* et son complément "cylindrique" CIE L*C*h, c'est chose faite.
J'ai rajouté une option dans mon prog de test pour colorer les cellules (je suis parti d'une bête fonction LCHtoRGB, qui englobe LCHtoLAB, puis LABtoXYZ et enfin XYZtoRGB), et je m'appuie toujours sur la fonction "BlackBox" d'il y a quelques jours pour la couleur des textes, et ça donne ça :


Il reste des cafouillages, notamment en col 5 ligne 2, col 6 ligne 7 et dernière col ligne 5, je crois que c'est inévitable, mais dans l'ensemble c'est pas mal du tout.
Ceux qui veulent pinailler/affiner se rajouteront un curseur pour contrôler la BlackBox et hop !

[wiwaxia]

Bonjour,

Envoyé par wiwaxia
[...] On a accordé beaucoup trop d'importance (moi le premier) à des simplifications anecdotiques dont l'intérêt apparaît finalement contestable, à part soulager le lecteur tétanisé par les mathématiques .
Ah, je me reconnais, là,

Tu n'est pas le seul, et cela ne t'empêche pas de mettre au point de belles palettes.

... Il reste des cafouillages, notamment ... , je crois que c'est inévitable, mais dans l'ensemble c'est pas mal du tout ...

Il y a toujours des cas décevants, près de la frontière, que rien n'interdit de déplacer un peu (L = 24 ou 26 %); tu es par ailleurs désavantagé par la finesse des caractères affichés, qui ne facilite pas leur perception: essaie, si tu peux, le passage aux caractères gras.

# C'est seulement après coup, faute d'un bonne vue, que j'ai perçu l'aspect fortement dégradé du tracé des graphes d'égal éclairement L(x, y) = C^te; cette altération ne relevait ni de la présence des pixels, ni de la compression.

La cause a été vite repérée: le balayage comportait le calcul de 5 points par pixel, afin de maintenir la continuité du graphe et d'éviter l'apparition des pointillés; et la détermination de la luminance locale L(x, y) passait par celle du pixel virtuel correspondant, triplet d'entiers obtenus par arrondi:

Code :

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

TYPE Pixel = ARRAY[1..3] OF Byte;

Tout est rentré dans l'ordre après son remplacement par un vecteur de (R³), triplet de réels qui dispense d'utiliser la fonction Round(.):

Code :

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

TYPE Lst3R = ARRAY[1..3] OF Extended;

Ainsi la seconde image, dont les dessins ont été soustraits:

# Avant correction: # Après:

Le contraste devient saisissant au voisinage des points singuliers, lorsque la luminance L(x, y) devient quasi-constante: les isophotes sont alors méconnaissables - elles correspondent toujours à L = 0.25 , mais il a fallu monter à 15 points calculés par pixel afin de préserver la continuité, compte tenu de l'inclinaison des branches.

# Avant correction: # Après:

D'où la nécessité de prendre garde à l'usage involontaire des fonctions discontinues (Round, Int, Trunc ... etc) en cours de calcul.

Je crois avoir lourdement insisté sur ce point par le passé Faîtes ce que je dis, ne faîtes pas ce que je fais !

[Jipété]

Bonjour,

je reviens sur ce sujet 9 mois tout ronds plus tard (à 3 jours près, on va pas chipoter), juste le temps de faire un beau bébé,

Ayant détecté des accrocs dans la première version (

Il reste des cafouillages, notamment en col 5 ligne 2, col 6 ligne 7 et dernière col ligne 5

), j'ai remis tout ça sur l'établi à l'atelier, j'ai repris la perceuse, la lime et le marteau, l'accouchement a été un peu laborieux, voir ici, mais au final, tout est bien qui finit bien.

Pour vous montrer, j'ai réalisé ce petit .gif avec des couleurs de fonds de cellule aléatoires, et les couleurs du texte à la recherche du contraste perdu (on dirait du Proust, ).
Il y a 3 images qui s'enchaînent, les différences de rendu sont pilotées par une variable "seuil" qui oscille entre 16 et 20 par pas de 2, répercutée sur la variable L du triplet LCh.


Entre 16 et 20 il y a 18, qui correspond dans la littérature au milieu du chemin visuel allant du noir au blanc.

Ma fonction de création de couleur inversée devient donc (seuil = variable globale positionnée par un curseur) :

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
function CouleurOpposee(Lorig, Corig, Horig: double): TColor;
var
  Lopp, Copp, Hopp: double; // LCH opposé
begin
  // 90 et 10 sont arbitrairement choisis pour donner des couleurs très claires ou très sombres,
  // très saturées ou très peu saturées, à l'inverse de la couleur originale
 
  if Lorig < seuil then Lopp := 90 else Lopp := 10; // inversion avec seuil pour L
  if Corig < 50 then Copp := 90 else Copp := 10;    // inversion sans seuil pour C, fixé à 50
  if Horig < 180 then Hopp := Horig + 180 else Hopp := Horig - 180; // diamétral. opposé sur le cercle chroma
 
  // 2 cas particuliers : noir et blanc
  if (Lorig =   0) and (Corig = 0) then begin Lopp := 100; Copp := 0; end;
  if (Lorig = 100) and (Corig = 0) then begin Lopp :=   0; Copp := 0; end;
 
  // sécurités :
  if Hopp < 0 then Hopp := 0; if Hopp > 359 then Hopp := 0;
 
  Result := LCHtoRGB(Lopp, Copp, Hopp);
end;

Passez de bonnes fêtes avec tout ça,

[sevyc64]