Discussion :

[Charly910]

Bonjour,

pour éclaircir une couleur TColor d'un pourcentage donné, peut on jouer sur les composantes R, G, B ou doit on passer par une conversion TSL ?

A+
Charly

[Lung]

Code :

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

1
2
3
GetRValue()
GetGValue()
GetBValue()

avec si besoin ColorToRGB()

[Charly910]

Merci Lung,

Mais ma question portait sur la différence des 2 méthodes.

J'ai fait des tests : diminuer les composantes RGB ou abaisser la luminosité en TLS, ça semble peu différent à l'oeil

A+
Charly

[Informt2025]

Pour quel but, changer la couleur d'un contrôle ou les pixels d'une image pour le dernier utiliser SetColorAdjustment qui est plus rapide

exemple
https://www.developpez.net/forums/d2.../#post12061811

[Charly910]

C'est dans un programme de dessin, pour modifier la couleur des pixels d'un outil spray

A+
Charly

[popo]

Il est possible de jouer sur les valeurs RGB en ajoutant une valeur fixe (k) à R, G et B.
R2=Min(R+k, 255)
G2=Min(G+k, 255)
B2=Min(B+k, 255)

C'est la méthode que j'avais utilisée à mes tout début.
Mon prof l'avais jugé simpliste mais fonctionnel pour mon niveau de l'époque.

Il serait en effet plus efficace de convertir en TSL et augmenter L.

Edit :
Ce lien montre le calcul pour passer de RGB à HSL.
https://www.rapidtables.com/convert/...gb-to-hsl.html

[ShaiLeTroll]

Si tu veux changer toute une image d'un coup SetColorAdjustment avant l'utilisation de StretchBlt en utilisant directement les API à partir du handle du Canvas,
c'est plus performant mais c'est aussi le plus monolithique, c'est toute l'image source qui est impacté lors de la copie.


RVB -> TSL/HLS -> RVB via ColorRGBToHLS et ColorHLSToRGB de GraphUtil (c'est des API Windows normalement ça existe en D7 mais pas en D6), ce n'est pas performant dans le cas d'une grande quantité de pixe mais une couleur d'un "pinceau" ça passe en TSL/HLS car c'est plus simple à modifier le Lumoniosité.

Tu peux le faire en RVB directement, c'est un petit calcul qui trainait sur la FAQ, je ne l'ai pas retrouvé, pourtant, j'avais déjà utilisé un code du forum qui le faisait (ou alors j'ai haluciné)
la proposition de popo peut faire illusion pour un profane (je l'ai utilisé aussi) mais si l'outil est plus destiné à un graphiste, il pourrait pinailler car on augmente pas les canaux RVB de la même façon pour la luminosité (car ça fausse la saturation)

Par contre pour un spray dans une application de dessin, j'ai peur que cela soit plus compliqué
Est-ce tu veux gérer l'aspect de dispersion du spray ?
plus dense au centre, plus diffu sur le contour, du coup est-ce plutôt de la transparence/mélange de couleur que la luminosité ?

[Charly910]

Merci à tous,

j'ai opté pour le plus simple et le plus rapide. ça donne de bons résultats :

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
function LightenColor(Color: TColor; Percent: Integer): TColor;
  // Percent : 0 à 100 (très clair)
var
  r, g, b: Byte;
begin
  Color := ColorToRGB(Color);
 
  r := GetRValue(Color);
  g := GetGValue(Color);
  b := GetBValue(Color);
 
  r := r + MulDiv(255 - r, Percent, 100);
  g := g + MulDiv(255 - g, Percent, 100);
  b := b + MulDiv(255 - b, Percent, 100);
 
  Result := RGB(r, g, b);
end;

Différence invisible avec HLS

A+
Charly

[Informt2025]

Ça ressemble à un contrôle de luminosité et pas la saturation,
Il y a une fonction similaire dans la lib jvcl

https://github.com/project-jedi/jvcl...intFX.pas#L589

[Charly910]

Oui, éclaircir c'est ce que je veux.
Je ne veux pas utiliser de composants tiers quand c'est possible.

A+
Charly

[ShaiLeTroll]

Tente ceci voir si c'est plus rapide ou pas ?

l'extraction de RGB via GetRValue c'est à base de shl/shr et masque binaire, si tu l'invoque dans une boucle, ça finira par se sentir
Tente cette approche via l'alignement des registres

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
 
function LightenColor(Color: TColor; Percent: Integer): TColor;
  // Percent : 0 à 100 (très clair)
 
type
  TRGBAColor = packed record
    case integer of
    1: (
       cR, cG, cB, cA: Byte;
       );
    2: (
       Color: TColor;
       );
  end;
 
var
  rgba: TRGBAColor;
begin
  rgba.Color := Color;
 
  rgba.cR := rgba.cR + MulDiv(255 - rgba.cR, Percent, 100);
  rgba.cG := rgba.cG + MulDiv(255 - rgba.cG, Percent, 100);
  rgba.cB := rgba.cB + MulDiv(255 - rgba.cB, Percent, 100);
 
  Result := rgba.Color;
end;

une version que D7 pourrait refuser mais plus rapide encore

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
 
function LightenColor(Color: TColor; Percent: Integer): TColor;
  // Percent : 0 à 100 (très clair)
 
type
  TRGBAColor = packed record
    case integer of
    1: (
       cR, cG, cB, cA: Byte;
       );
    2: (
       Color: TColor;
       );
  end;
 
begin
  Result := Color;
 
  with TRGBAColor(Result) do
  begin
    cR := cR + MulDiv(255 - cR, Percent, 100);
    cG := cG + MulDiv(255 - cG, Percent, 100);
    cB := cB + MulDiv(255 - cB, Percent, 100);
  end;
end;

[Charly910]

Merci, Shai, je vais tester tes versions

A+
Charly

[Charly910]

Les 2 versions fonctionnent sous D7, je garde la seconde

A+
Charly

[Charly910]

Tant qu'à faire, j'ai permis Percent >0 pour éclaircir ou <0 pour foncer dans ton code :

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
{ =============================================================== }
function LightenColor(Color: TColor; Percent: Integer): TColor;
  // Percent : -100 très foncé à 100 très clair
type
  TRGBAColor = packed record
    case integer of
    1: (cR, cG, cB, cA: Byte;);
    2: (Color: TColor;);
  end;
var
  rgba: TRGBAColor;
begin
  Result := Color;
  if Percent > 0 then
    with TRGBAColor(Result) do
      begin
        cR := cR + MulDiv(255 - cR, Percent, 100);
        cG := cG + MulDiv(255 - cG, Percent, 100);
        cB := cB + MulDiv(255 - cB, Percent, 100);
      end
  else
    with TRGBAColor(Result) do
      begin
        cR := MulDiv(cR, 100 + Percent, 100);
        cG := MulDiv(cG, 100 + Percent, 100);
        cB := MulDiv(cB, 100 + Percent, 100);
      end;
 end;
{ =============================================================== }

Reste éventuellement à blinder percent entre -100 et + 100

A+
Charly

[anapurna]

Tant qu'à faire, j'ai permis Percent >0 pour éclaircir ou <0 pour foncer dans ton code :

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
{ =============================================================== }
function LightenColor(Color: TColor; Percent: Integer): TColor;
  // Percent : -100 très foncé à 100 très clair
type
  TRGBAColor = packed record
    case integer of
    1: (cR, cG, cB, cA: Byte;);
    2: (Color: TColor;);
  end;
var
  rgba: TRGBAColor;
begin
  Result := Color;
  if Percent > 0 then
    with TRGBAColor(Result) do
      begin
        cR := cR + MulDiv(255 - cR, Percent, 100);
        cG := cG + MulDiv(255 - cG, Percent, 100);
        cB := cB + MulDiv(255 - cB, Percent, 100);
      end
  else
    with TRGBAColor(Result) do
      begin
        cR := MulDiv(cR, 100 + Percent, 100);
        cG := MulDiv(cG, 100 + Percent, 100);
        cB := MulDiv(cB, 100 + Percent, 100);
      end;
 end;
{ =============================================================== }

Reste éventuellement à blinder percent entre -100 et + 100

A+
Charly

Salut

quelque soit le pourcentage ta valeur ne doit pas dépasser 255
voici les fonction que tu devrais utiliser pour la variation de luminosité

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
 
Function Darkness(Color: TColor; Percent: Integer) : TColor;
var
   rgba: TRGBAColor;
begin
   Result := Color;
   with TRGBAColor(Result) do
   begin
      {cR  := IntToByte(cR - (cR * Percent) div 255);
        cG := IntToByte(cG - (cG * Percent) div 255);
        cB  := IntToByte( cB - ( cB * Percent) div 255);
     }
      cR  := cR - MulDiv(cR , Percent, 255);
      cG  := cG - MulDiv(cG , Percent, 255);
      cB  := cB - MulDiv( cB , Percent, 255);
  End;
end;
 
Function Lightness(Color: TColor; Percent: Integer) : TColor;
var
   rgba: TRGBAColor;
begin
   Result := Color;
   with TRGBAColor(Result) do
   begin
    {  cR := IntToByte(cR + ((255 - cR) * Percent) div 255);
       cG := IntToByte(cG + ((255 - cG) * Percent) div 255);
       cB := IntToByte(cB + ((255 - cB) * Percent) div 255);
    }
      cR := cR + MulDiv(255 - cR, Percent, 255);
      cG := cG + MulDiv(255 - cG, Percent, 255);
      cB := cB + MulDiv(255 - cB, Percent, 255);
  End;
end;

bien entendu le pourcentage est entre 0 et 100

il existe des fonction toute faite dans delphi
genre :

Code :

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

 function GetHighLightColor(const Color: TColor): TColor;

ou

Code :

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

 function GetShadowColor(const Color: TColor): TColor;

qui te fournis une couleur "aproprié" selon la couleur choisi. elles se trouvent dans GraphUtil

[ShaiLeTroll]

...RVB -> TSL/HLS -> RVB via ColorRGBToHLS et ColorHLSToRGB de GraphUtil (c'est des API Windows normalement ça existe en D7 mais pas en D6), ...
Tu peux le faire en RVB directement, c'est un petit calcul qui trainait sur la FAQ, je ne l'ai pas retrouvé, pourtant, j'avais déjà utilisé un code du forum qui le faisait (ou alors j'ai haluciné)

Merci anapurna !
GetHighLightColor et GetShadowColor, c'était ça que je cherchais hier, c'était pas du forum mais dans Delphi, GraphUtil en D7, je crois que rien n'était documenté sur cette unité (nouvelle à l'époque je crois)

[anapurna]

Merci anapurna !
GetHighLightColor et GetShadowColor, c'était ça que je cherchais hier, c'était pas du forum mais dans Delphi, GraphUtil en D7, je crois que rien n'était documenté sur cette unité (nouvelle à l'époque je crois)

Salut

si je me souviens bien elles sont là depuis D6 mais non documentées

[Charly910]

Bonjour Anapurna,

tes formules me semblent bizarres. Par exemple :

cR := cR + MulDiv(255 - cR, Percent, 255);
soit :
cR := cR + (255-cR) * Percent / 255

cR := cr + 255 * Percent / 255 - cr * Percent / 255

pour Percent = 100 et Cr = 128 ==> 177,8 au lieu de 255

avec la mienne :

cR := cR + MulDiv(255 - cR, Percent, 100);

cr := cR + (255 - cR) * Percent / 100

pour Percent = 100 et cR = 128 ==> 255

A+
Charly

[der§en]

Je chicane mais cela me pique un tout petit petit petit peu, pourquoi ceci:

Code :

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

case integer of

pour un choix binaire, ceci ne faciliterai pas la compréhension:

Code :

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

case boolean of

?

[anapurna]

Bonjour Anapurna,

tes formules me semblent bizarres. Par exemple :

cR := cR + MulDiv(255 - cR, Percent, 255);
soit :
cR := cR + (255-cR) * Percent / 255

cR := cr + 255 * Percent / 255 - cr * Percent / 255

pour Percent = 100 et Cr = 128 ==> 177,8 au lieu de 255

avec la mienne :

cR := cR + MulDiv(255 - cR, Percent, 100);

cr := cR + (255 - cR) * Percent / 100

pour Percent = 100 et cR = 128 ==> 255

A+
Charly

Salut

je n'ai fait que transcrire la fonction du liens donnés plus haut
project-jediL589

PS je viens de m'apercevoir que ce n'est pas un pourcentage que l'on attend mais une valeur entre 0 et 255