Discussion :

[Jipété]

Bonjour,

Le traitement mathématique des couleurs n'étant pas trop ma tasse de thé, j'ai besoin d'un petit coup de pouce pour (essayer de) convertir l'image colorée ci-dessous en une autre image colorée qui se comporterait comme l'image en niveaux de gris, qui est bien lisse et uniforme, avec un dégradé bien régulier.


L'image en couleur est construite à partir d'un algo classique d'arc-en-ciel de gauche à droite mâtiné de dégradé de haut en bas, le tout à base des couleurs R,G,B pures de 0 à 255 (source).
Le dégradé gris c'est l'image en couleur trafiquée par The Gimp à qui j'ai demandé une désaturation et qui m'a proposé 3 options, celle qu'on voit c'est le choix Lightness dont l'aide me dit :

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

Alors dans ma tentative de traitement j'ai bien extrait les composantes H,S,L de l'image et j'ai appliqué cette formule à L avant de réencoder pour affichage, mais ça me donne une image psychédélique dont on dirait qu'elle a été peinte sous acide en écoutant Jerry Garcia...
J'ai tenté de rajouter une option de balayage vertical avec formule * h/(Height-1) ("h" c'est le compteur de boucle pour le balayage vertical) mais pas mieux...

J'en suis là, alors si quelqu'un a une idée, je la lirai avec grand plaisir (pour peu qu'elle soit écrite avec des mots simples ).

Merci,

[anapurna]

salut

pourquoi appliquer cette formule a L ?
il te donne la formule pour trouver le L a partir du RGB
Soit ta valeur RGB X

R'= R/255
G' = G/255
B' = B/255

Cmax := max(R',G',B')
Cmin := min(R',G',B')
Delta := Cmax-Cmin

Pour trouver H (la teinte):

Si delta = 0 alors H = 0
si Cmax = R' alors H = 60 *(((G'-B')/Delta) mod 6) // cas du rouge
si Cmax = G' alors H = 60 *(((B'-R')/Delta)+2) // cas du vert
si Cmax = B' alors H = 60 *(((R'-G')/Delta)+4) // cas du vert

Pour le ligtness (ou luminance ...tu connais la formule mais bon je la redonne)

L= (Cmax+Cmin)/2

pour trouver S (saturation)

Si delta = 0 alors S = 0
sinon S = delta/(1-Abs(2*L-1))

pour faire l'inverse

il te faut calculer quelque éléments

C = ((1-Abs(2*L-1))*S // valeur déterminé par la saturation
X = C*(1-abs(((H/60) mod 2) -1) // valeur défini par la teinte
m = L - C/2 // valeur défini par la luminance

si H est entre 0 et 60 Alors Col' =[C,X,0]
si H est entre 60 et 120 Alors Col' =[X,C,0]
si H est entre 120 et 180 Alors Col' =[0,C,X]
si H est entre 180 et 240 Alors Col' =[0,X,C]
si H est entre 240 et 300 Alors Col' =[X,0,C]
si H est entre 240 et 300 Alors Col' =[C,0,X]

on replace tout

COLRGB = RGB((Col'[0]+m)*255,(Col'[1]+m)*255,(Col'[2]+m)*255);

[Jipété]

Salut salut (mais tu es partout )

pourquoi appliquer cette formule à L ?

Parce que je n'avais pas d'autre idée, et que j'étais loin de pouvoir envisager les calculs que tu as postés...

il te faut calculer quelque éléments

Et c'est là que ça se complique :

X = C*(1-abs(((H/60) mod 2) -1) // valeur définie par la teinte

Cette cochonnerie de Lazarus ne sait pas appliquer "mod" sur des float, et je n'arrive pas à trouver l'équivalent pour des float... Et tu sais ce que c'est que l'aide de Lazarus : il te faut connaître le mot pour espérer de l'aide dessus, le serpent qui se mord la queue...
Bref, je suis coincé là, en plus j'ai du mal à décoder ce que tu veux, il y a une parenthèse ouvrante de trop (ou une fermante absente : auquel cas, où serait-elle ?)

si H est entre 0 et 60 Alors Col' =[C,X,0]

Et Col' pour toi c'est quoi ? Une Array[0..2] de byte ?

Merci,

[anapurna]

salut

si tu fait une division entière au lieu d'une division cela marchera peut être mieux

abs(((H DIV 60) mod 2)

sinon un tableau d'entier pour la question sur le tableau

[anapurna]

salut

il y a plus simple ^^
unité graphutil.pp voir ici

[Jipété]

salut

il y a plus simple ^^
unité graphutil.pp voir ici

Ben non, parce qu'il faut modifier L, sinon on se retrouve avec l'image d'origine (testé ce matin)

Mais sinon on approche :


Comme ça jusqu'au bout à droite. C'est un joli rouge

La question est : est-ce que j'ai bien fait (je ne mets que la partie balayage horizontal) :

Code pascal :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for w := 0 to (Width - 1) do begin
  with s[w] do begin // s c'est un pointeur sur le RGBQuad de la source (le ScanLine de Lazarus)
    ConvertRGBtoHSL(rgbRed,rgbGreen,rgbBlue, H,S,L); // on récupère les composants du RGBQuad qu'on convertit en H,S,L
    L := (MaxValue([rgbRed,rgbGreen,rgbBlue]) + MinValue([rgbRed,rgbGreen,rgbBlue])) * 0.5;
    C := round((1-Abs(2*L-1))*S);
    X := round(C*(1-Abs((round(H) div 60) mod 2)-1));
    m := round(L-C/2);
    if (  0 >= H) and (H <  60) then begin col[0] := C; col[1] := X; col[2] := 0; end;
    if ( 60 >= H) and (H < 120) then begin col[0] := X; col[1] := C; col[2] := 0; end;
    if (120 >= H) and (H < 180) then begin col[0] := 0; col[1] := C; col[2] := X; end;
    if (180 >= H) and (H < 240) then begin col[0] := 0; col[1] := X; col[2] := C; end;
    if (240 >= H) and (H < 300) then begin col[0] := X; col[1] := 0; col[2] := C; end;
    if (300 >= H) and (H < 360) then begin col[0] := C; col[1] := 0; col[2] := X; end;
  end;
  d[w] := RGBAtoRGBAQuad((col[0]+m)*255, (col[1]+m)*255, (col[2]+m)*255, 255); // destination : un autre RGBQuad

Et ce qui me fait peur c'est de travailler avec des integer quand H,S et L sont des float : je vais perdre la précision des float...

[Jipété]

J'ai rajouté une ligne de log pour essayer de comprendre :

Code pascal :

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

1
2
3
4
5
...
m := round(L-C/2);
mainform.Memo1.Lines.Add(floattostr(L)+'  '+inttostr(C)+'  '+inttostr(X)+'  '+inttostr(m));
if (  0 >= H) and (H <  60) then begin col[0] := C; col[1] := X; col[2] := 0; end;
...

et voilà ce que j'ai relevé ( 393xxx lignes,quand même !) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
            L     C   X   m
0 à 1535 : 255   000  0  255
2e ligne : 254  -506  0  507
3e ligne : 253  -504  0  505
4e ligne : 252  -502  0  503
5e ligne : 251  -500  0  501
6e ligne : 250  -498  0  499
7e ligne : 249  -496  0  497
...
avant-der:   1     0  0    1
dernière :   0     0  0    0

Du début à la fin X est à 0, c'est pas top je crois !

X := round(C*(1-Abs((round(H) div 60) mod 2)-1));

Entre les round et les div, je sens bien que ça nous fout dedans...

[anapurna]

salut

effectivement tu perd de la précision
par contre je ne vois pas ce qui t’empêche d'utiliser les fonction prédéfinie dans graphutil
il existe suffisament de fonction pour le faire voir par là
sinon pour pas trop perdre tu peut peut etre multiplier par 100

pour trouver le mod d'un nombre c'est assez simple

amod := Avalue - round(Avalue / adiv) ;

[Jipété]

salut

effectivement tu perds de la précision
par contre je ne vois pas ce qui t’empêche d'utiliser les fonctions prédéfinies dans graphutil

Je te l'ai dit tout-à-l'heure, ça ne va pas me faire varier L... Réfléchis : si pour tous les points de l'image, 1 par 1, je les convertis de RGB en HSL puis de HSL en RGB ça m'avance à quoi ?
Il faut une intervention mathématique entre les deux conversions mais je ne sais pas laquelle...

pour trouver le mod d'un nombre c'est assez simple

Résultat image noire rouge à blanc comme tout-à-l'heure (erreur de commentaires mal mis/mal enlevés), car tu ne m'as toujours pas dit où était l'erreur avec les parenthèses, que je t'ai signalée : une en trop ou une en moins, et où ?

X := C*(1-abs(((H/60) mod 2) -1); // valeur définie par la teinte

Compte : 4 ouvrantes et 3 fermantes, ça ne peut pas aller !

[anapurna]

Salut

X := C*(1-abs(((H/60) mod 2) -1)); // valeur définie par la teinte

oups j'ai oublié la dernière parenthèse


PS : le simple fait de décrémenter ou incrémenter L devrais suffire non ?
Il faut que tu borne simplement ta valeur entre o et 100
la luminance et la saturation sont des pourcentage

[Jipété]

Salut



oups j'ai oublié la dernière parenthèse

Mais sinon, toujours cette double image rouge d'un bout à l'autre et c'est tout...

D'ailleurs, tiens, pour changer ça :
L := (MaxValue([rgbRed,rgbGreen,rgbBlue]) + MinValue([rgbRed,rgbGreen,rgbBlue])) * 0.25; // 2 fois l'img divisée par 2 avec 0.5 (qui est le standard)

On n'est pas loin, mais on n'y est pas...

PS : le simple fait de décrémenter ou incrémenter L devrait suffire non ?

Non, il faut récupérer H et le faire dégrader (de haut en bas) et corriger (par le L calculé), au fur et à mesure de l'avancement horizontal. Enfin, c'est comme ça que je vois la chose.

Bon, j'ai faim

Bon app, à pluche ou à demain...

[Jipété]

pour trouver le mod d'un nombre c'est assez simple

amod := Avalue - round(Avalue / adiv) ;

T'es sûr de ça ? Parce que j'ai vérifié et c'est un poil plus compliqué (pour les float ; pas vérifié pour les integer) : aMod := aValue - (Trunc(aValue / aDiv)) * aDiv;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TMainForm.Button4Click(Sender: TObject);
var
  aValue, aDiv, aMod: float;
begin
  aValue := 7;
  aDiv := 3;
  aMod := aValue - round(aValue / aDiv) ;
  showmessage(floattostr(aMod)); // 5 avec 7 et 3, 11 avec 15 et 4 -- n'importe quoi !
  aMod := aValue - (Trunc(aValue / aDiv)) * aDiv;
  showmessage(floattostr(aMod)); // OK
end;

il te faut calculer quelque éléments

C = ((1-Abs(2*L-1))*S // valeur déterminée par la saturation
X = C*(1-abs(((H/60) mod 2) -1) // valeur définie par la teinte
m = L - C/2 // valeur définie par la luminance

Elles sortent d'où, ces formules ?
Et tu es sûr de ton coup, pour la 3^e ligne ? Parce que par exemple, selon comment on met les parenthèses

Code :

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

1
2
m := L-(C/2); // joli rouge à blanc
m := (L-C)/2; // joli noir à bleu

Bon, j'ai tout repris ligne à ligne, j'avais dû louper une parenthèse, maintenant je n'ai même plus de dégradé uniforme :

Et c'est comme ça jusqu'au bord droit... Tu noteras que tout en haut et au milieu il y a une ligne d'une autre couleur.

Un truc que je ne comprends pas dans ton premier post, c'est tout ce développement pour extraire HSL alors que j'ai une fonction pour le faire, relis mon code, au début il y a

Code :

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

1
2
        with ss[w] do begin
          ConvertRGBtoHSL(rgbRed,rgbGreen,rgbBlue, H,S,L);

Alors pourquoi le refaire ?
Car je récupère des pRGBQuad (ss pour "source", on ne s'occupe pas du 4^e octet pour la transparence) et ma fonction extrait tout bien, plus qu'à retravailler et c'est là que je coince.

Bon, la nuit porte conseil, comme dit le proverbe

[anapurna]

salut

ah oui pour le amod j'ai oublier de multiplier par le diviseur

les formule sont celle qui permet de passer du RGB au HSL et vis et versa => donc normalement sans modification de la couleur
toutes ces formules sont dispo sur wiki vers le bas de page

[Jipété]

Yep !

toutes ces formules sont dispo sur wiki vers le bas de page

ah oui, je les ai souvent vues, moi j'ai utilisé celles qu'on trouve ici, bien sympathiques aussi.

Ceci étant dit, je crois que ma demande est irréalisable... J'ai fait des tests, ce matin : j'ai généré une image d'arc-en-ciel uniforme sans dégradés de blanc vers noir et une autre image noir et blanc de dégradé de blanc vers noir, je les ai mises ensemble comme 2 calques dans Gimp et j'ai essayé toutes les possibilités de fusion de calques sans arriver à ce que je cherche.

J'en conclus que ce n'est pas possible, alors on ne va pas se prendre la tête plus que ça... Faut savoir laisser tomber, des fois.

Merci pour le temps que tu y as passé.

[tbc92]

On peut reprendre au tout début ?

Pour obtenir le dégradé en question, on te dit : L = ( max ( R,G,B) + min ( R,G,B) ) /2
Cette formule est embêtante,car elle combine les composantes RGB, et les composantes HSL

Si tu veux utiliser cette transformation, en travaillant avec les composantes RGB uniquement, ça donne :
x = ( max ( R,G,B) + min ( R,G,B) ) /2
R = x
G = x
B = x
Je ne suis pas tout à fait sûr que ce soit exactement ça, mais la différence ne sera pas visible à l'oeil nu.


Et si tu veux travailler avec les composantes HSL uniquement, ça donne :
L = inchangé
S = 0
H = ce que tu veux ; quand S vaut 0, H n'a pas d'effet.

[Jipété]

On peut reprendre au tout début ?

Pour obtenir le dégradé en question, on te dit : L = ( max ( R,G,B) + min ( R,G,B) ) /2
Cette formule est embêtante,car elle combine les composantes RGB, et les composantes HSL

Si tu veux utiliser cette transformation, en travaillant avec les composantes RGB uniquement, ça donne :
x = ( max ( R,G,B) + min ( R,G,B) ) /2
R = x
G = x
B = x
Je ne suis pas tout à fait sûr que ce soit exactement ça, mais la différence ne sera pas visible à l'oeil nu.

En utilisant cette formule, je gagne un très joli, très doux et très délicat dégradé de... gris
C'est le même en couleurs que j'aurais voulu mais, comme je le disais ce matin, je crois bien que ce n'est pas possible.

Par ailleurs, quand tu dis "Cette formule est embêtante, car elle combine les composantes RGB, et les composantes HSL", je ne vois pas où c'est embêtant, dans la mesure où les composantes HSL sont extraites par calcul des composantes RGB : je dirais que c'est la même chose présentée autrement.

'fin bon, de toute façon, ce que j'avais bien noté ce matin, c'est qu'en travaillant avec H,S,L, je me suis rendu compte qu'en fixant L à 0.5 par ex. pendant tout le processus (just 4 tests), le dégradé n'était pas parfait : présence d'artefacts dans les premières et dernières lignes, ce qui me fait supposer que jouer uniquement avec L ne serait pas suffisant.

Cette image est déformée pour bien faire apparaître les défauts : suppression de la partie intermédiaire, compression de la largeur et étirement de la hauteur.
Et en fait l'algo pour cette image est tout bête : je récupère H,S,L, je n'applique aucun traitement, je me contente de fixer L à 0.5 je fais réencoder et afficher et voilà.

C'est pour ça que je lâche l'affaire (à moins que quelqu'un ait la formule mathématique de la mort qui tue ).

[tbc92]

Adaptons un tout petit peu, pour avoir un dégradé de rouge par exemple : (Dégradé entre blanc et rouge)

Code :

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

1
2
3
4
5
 
x = ( max ( R,G,B) + min ( R,G,B) ) /2 
R = 255
G = x
B = x

A vérifier selon les outils, mais je pense que la valeur 255 est la bonne. ( si besoin, pour le vérifier, affiche les valeurs R , G et B qui correspondent à la couleur Blanc)

Tu peux aussi t'amuser en testant ça (dégradé entre rouge et vert) :

Code :

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

1
2
3
4
5
 
x = ( max ( R,G,B) + min ( R,G,B) ) /2 
R = x
G = 255-x
B = 0

[anapurna]

salut

pour éviter les débordement tu peut utiliser un min normalement ce n'est pas possible dans le cas present mais
cela est toujours bon de borner pour le jour ou on modifie son code et pour la division par deux préfère un DIV il te donneras un entier plutôt

Code :

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

x = Min( (max ( R,G,B) + min ( R,G,B) ) DIV 2 ,255)

[Jipété]

pour éviter les débordement tu peut utiliser un min normalement ce n'est pas possible dans le cas present mais
cela est toujours bon de borner pour le jour ou on modifie son code

Bah, ce n'est pas ça qui était utilisé lors de la génération des artefacts : juste la récupération sans modif de H et S, et passage de L à 0.5.

Adaptons un tout petit peu, pour avoir un dégradé de rouge par exemple : (Dégradé entre blanc et rouge)

Tu peux aussi t'amuser en testant ça (dégradé entre rouge et vert)

Oui, c'est gentil à toi mais je connais ces manips, ce n'es pas le dégradé d'une couleur qui m'intéresse, c'est le dégradé de toute l'image. Tu me diras que l'image n'est jamais qu'une suite de colonnes, chacune avec sa couleur, dégradée de blanc vers noir, je sais bien et c'est pour ça que j'essayais de jouer sur le L, sans bons résultats.

Je reste persuadé que ce que nous voyons dans l'arc-en-ciel dégradé du 1^er post et qui me déplaît (d'où cette discussion) est en fait impossible à annuler, et ces effets visuels désagréables sont juste normaux.
D'ailleurs en faisant des copies d'écran de zones "moches" (le triangle bleu foncé, la croix au milieu du jaune, par ex.) et en zoomant, l'effet "moche" n'est plus du tout visible.

[anapurna]

salut

si je comprend bien tu veut soit augmenter la luminosité soit le contraste sur toutes l'image donc le paramètre ne dois pas varier d'un pixel a l'autre

dans ce cas tu peut appliquer ces formules

pour éclaircir
//Luminosité :
R := round(R * ( 1 + intens / 100));
G := round(G * ( 1 + intens / 100));
B := round(B * ( 1 + intens / 100));

pour foncer
//Contraste:
R := round(R + intens / 100 * (R-127));
G := round(G + intens / 100 * (G-127));
B := round(B + intens / 100 * (B-127));


n'oublie pas le min pour borner a 255
et le max pour borner a 0

Code :

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

Max(0,min(mavaleur,255))