RGB-Farben ändern ?

[Hansa]

Hi,

ich habe hier eine bestimmte Farbe, die soll als Farbe so bleiben, aber heller oder dunkler. Deshalb nehme ich an, alle 3 Werte verändern zu müssen. Nur, wie setzen die sich zusammen ? Hat da jemand ein Beispiel ?

[fkerber]

Hi!

Da gibts bestimmt noch was tolleres, aber mal als Ansatz:

http://selfhtml.teamone.de/diverses/...alette_216.htm


Ciao fkerber

[Hansa]

Das ist doch schon mal was. Der Zusammenhang war mit anderen Farbtabellen nicht so erkennbar. *freu* Ist es richtig, daß jeweils 2 Hex-Stellen für R,G und B stehen ? Insofern bräuchte ich ja nur alle drei gleichmäßig zu verringern oder erhöhen, für heller oder dunkler ? Nun ja, ich bin leider kein Maler. :lol:

[czapie]

RGB ist glaub ich additive Farbmischung,
somit müßte eigentlich das Verhältnis der drei Komponenten zueinander gleich
bleiben, und nicht um gleiche Werte modifiziert werden.

Czapie.

[fkerber]

Diese Tabelle befasst sich halt nur mit den sicheren Webfarben!
Aber bei den Grauwerten war es irgenwie so:

#ffffff // weiß
#eeeeee // hell
#dddddd //dunkler
#cccccc //dunkler
#bbbbbb //dunkler
#aaaaaa //dunkler
#666666 // dunkler
#555555 //dunkler
[...]
#000000 schwarz


Geht man davon aus, dass #0000FF helles blau ist, dann wird es dunkler, wenn man die FF runterschraubt bis schließlich 11 (Eins,eins = kaum noch erkennbar blau, fast schwarz).

Wenn ich nicht irre sind die RGB-Farben ja so

1.+2. Stelle Rot-Anteil
3.+4. Stelle Grün-Anteil
5.+6. Stelle Blau-Anteil

Anhand der genannten Farb-Tabelle sieht man ja einige weitere Farben und kann die dann wieder nach dem oben beschriebenen System abschwächen!

Hoffe das hilft mal!

Ciao fkerber

[Hansa]

Hi,

ja die Mischung von rot, grün und blau. Wenn ich jetzt von jedem die Intensität verringere, so ist die Farbe nicht so hell ansonsten aber gleich. Das muß nur gleichmäßig geschehen und nicht nur von einem Wert, das ergäbe tatsächlich eine andere Farbe. Nimmt man die drei Grundfarben und mischt diese in einem Eimer, so wird es schwarz. Beim Sonnenlicht ist es dann weiß. 8) Wie heißt noch der Begriff ? :gruebel:

Nun aber noch eine Frage : wie kann ich mit dem Kram so eine Art gestaffelte Schattierungstabelle basteln ?

[himitsu]

Delphi-Quellcode:

Var R, G, B: Byte;
  Farbe: TColor;
  HD: ShortInt;  { -100..0 = dunkler }
                 {  0..100 = heller  }

R := (Farbe and $000000FF);
G := (Farbe and $0000FF00) shr 8;
B := (Farbe and $00FF0000) shr 16;

If HD < 0 Then Begin
  R := R + (R * HD div 100);
  G := G + (G * HD div 100);
  B := B + (B * HD div 100);
End Else Begin
  R := R + ((255 - R) * HD div 100);
  G := G + ((255 - G) * HD div 100);
  B := B + ((255 - B) * HD div 100);
End;

{Farbe := R or (G shl 8) or (B shl 16);}
Farbe := RGB(R, G, B);

Angaben ohne Gewähr

http://www.delphipraxis.net/images/common/divider.jpg
http://www.FrankNStein.de/Smiley-Kuss.gif * * http://www.FrankNStein.de/Smiley-Spinne.gif * * * http://www.FrankNStein.de/Smiley-Winken.gif

[fkerber]

Hi!

Was meinst du mit gestaffelter Farbtabelle genau? Wie willst du die ausgeben?
So als Tipp ohne Hintergrund :lol: , nimm ein Array und orde die Element nach Helligkeit an, also FF, EE, DD, CC usw. und "misch" sie dann zusammen!

Also
#0000+ARRAY[0]
#0000+ARRAY[1] dunkler

usw!

Ciao fkerber

[Hansa]

Ich habe das jetzt mal umgesetzt. Mit 2 Buttons soll die Color der Form verändert werden (heller/dunkler) :

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
    R, G, B: Byte;
    Farbe: TColor;
    HD: ShortInt;  { -100..0 = dunkler }
                   {  0..100 = heller  }

  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  hd := -10;
  farbe := Color;
  R := (Farbe and $000000FF);
  G := (Farbe and $0000FF00) shr 8;
  B := (Farbe and $00FF0000) shr 16;

  R := R + (R * HD div 100);
  G := G + (G * HD div 100);
  B := B + (B * HD div 100);

{Farbe := R or (G shl 8) or (B shl 16);}
  Farbe := RGB(R, G, B);
  color := farbe;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  hd := 10;
  farbe := Color;
  R := (Farbe and $000000FF);
  G := (Farbe and $0000FF00) shr 8;
  B := (Farbe and $00FF0000) shr 16;

  R := R + ((255 - R) * HD div 100);
  G := G + ((255 - G) * HD div 100);
  B := B + ((255 - B) * HD div 100);
  Farbe := RGB(R, G, B);
  color := farbe;
End;

end.

Leider geht es so nicht. Erstens verstehe ich nicht genau, wozu die Variable hd gedacht ist. In der Praxis stört mich aber am meisten, daß sich bei abwechselnder Betätigung der heller/dunkler Buttons die Farben nicht mehr zurück stellen lassen, so wie sie vorher waren.

Mein Gespür, welches allerding nicht immer funktioniert :lol: meint zu dem Source, daß da etwas mit dem SHR und dem DIV nicht richtig ist. Werden da nicht HEX und Dezimaloperationen durcheinander gewirbelt :?:

[himitsu]

Mit ColorToRGB sollten natürlich vorher die Farbwerte der Farbpalette in RGB umgewandelt werden
clBtnFace ist zum beispiel kein RGB Wert, sondern verweißt auf einen Farbwert in der Systempalette.

Delphi-Quellcode:

Unit Unit1;

Interface
  Uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls;

  Type TForm1 = Class(TForm)
    Button1: TButton;
    Button2: TButton;
    Procedure Button1Click(Sender: TObject);
    Procedure Button2Click(Sender: TObject);
  End;

  Var Form1: TForm1;

Implementation
  {$R *.dfm}

  Procedure TForm1.Button1Click(Sender: TObject);
    Var R, G, B: Byte;
      Farbe: TColor;
      HD: ShortInt;  { -100..0 = dunkler / 0..100 = heller  }

    Begin
      HD := -10;
      Farbe := ColorToRGB(Color);
      R := (Farbe and $000000FF);
      G := (Farbe and $0000FF00) shr 8;
      B := (Farbe and $00FF0000) shr 16;
      R := R + (R * HD div 100);
      G := G + (G * HD div 100);
      B := B + (B * HD div 100);
      Color := RGB(R, G, B);
    End;

  Procedure TForm1.Button2Click(Sender: TObject);
    Var R, G, B: Byte;
      Farbe: TColor;
      HD: ShortInt;  { -100..0 = dunkler / 0..100 = heller  }

    Begin
      HD := 10;
      Farbe := ColorToRGB(Color);
      R := (Farbe and $000000FF);
      G := (Farbe and $0000FF00) shr 8;
      B := (Farbe and $00FF0000) shr 16;
      R := R + ((255 - R) * HD div 100);
      G := G + ((255 - G) * HD div 100);
      B := B + ((255 - B) * HD div 100);
      Color := RGB(R, G, B);
    End;

End.

HD gibt die starke der Änderung an.


http://www.delphipraxis.net/images/common/divider.jpg
http://www.FrankNStein.de/Smiley-Kuss.gif * * http://www.FrankNStein.de/Smiley-Spinne.gif * * * http://www.FrankNStein.de/Smiley-Winken.gif

[Hansa]

Die zweite Prozedur muß aussehen, wie die erste:

Delphi-Quellcode:

Procedure TForm1.Button2click;
Var R, G, B: Byte;
  Farbe: TColor;
  HD: ShortInt;  { -100..0 = dunkler / 0..100 = heller  }

Begin
  HD := 10;
  Farbe := ColorToRGB(Color);
  R := (Farbe and $000000FF);
  G := (Farbe and $0000FF00) shr 8;
  B := (Farbe and $00FF0000) shr 16;
(*
  R := R + ((255 - R) * HD div 100);
  G := G + ((255 - G) * HD div 100);
  B := B + ((255 - B) * HD div 100);
*)
  R := R + (R * HD div 100);
  G := G + (G * HD div 100);
  B := B + (B * HD div 100);
  Color := RGB(R, G, B);
  memo1.lines.add('***** heller *****  '+IntToStr (g));
End;

Und das bedeutet, man braucht eigentlich nur eine ! Das ganze kann dann einfach über den Wert von HD gesteuert werden.

[sakura]

Um eine farbtreue Veränderung zu erreichen, musst Du mit HSV/HSL/HSB arbeiten. Die RGB-Farbe muss dabei entsprechend in eines der Schemate umgewandelt werden. Bei HSB kannst Du dann die Brightness (B-Value) verändern und den wieder zurückverwandeln. Siehe auch: http://www.delphipraxis.net/internal...?p=70103#70103

...:cat:...

[himitsu]

Meintest du das zum Beispiel so?

Delphi-Quellcode:

Uses Math;

Procedure HDAnpassen(HD: ShortInt);
  { HD:   -100..0 = dunkler / 0..100 = heller }

  Var Farbe: TColor;
    R, G, B: Byte;

  Begin
    Farbe := ColorToRGB(Form1.Color);
    R := (Farbe and $000000FF);
    G := (Farbe and $0000FF00) shr 8;
    B := (Farbe and $00FF0000) shr 16;
    If HD < 0 Then Begin
      R := Trunc(R + (R * HD / 100));
      G := Trunc(G + (G * HD / 100));
      B := Trunc(B + (B * HD / 100));
      {Form1.Memo1.Lines.Add('***** dunkler *****  ' + IntToStr(R));}
      Form1.Memo1.Lines.Add('***** dunkler *****  ' +
        IntToStr(R) + ':' + IntToStr(G) + ':' + IntToStr(B));
    End Else Begin
      R := Ceil(R + ((255 - R) * HD / 100));
      G := Ceil(G + ((255 - G) * HD / 100));
      B := Ceil(B + ((255 - B) * HD / 100));
      {Form1.Memo1.Lines.Add('***** heller *****  ' + IntToStr(R));}
      Form1.Memo1.Lines.Add('***** heller *****  ' +
        IntToStr(R) + ':' + IntToStr(G) + ':' + IntToStr(B));
    End;
    Form1.Color := RGB(R, G, B);
  End;

Delphi-Quellcode:

Procedure TForm1.Button1Click(Sender: TObject);
  Begin
    (* 10% heller *)
    HDAnpassen(10);
  End;

Procedure TForm1.Button2Click(Sender: TObject);
  Begin
    (* 10% dunkler *)
    HDAnpassen(-10);
  End;

http://www.delphipraxis.net/images/common/divider.jpg
http://www.FrankNStein.de/Smiley-Kuss.gif * * http://www.FrankNStein.de/Smiley-Spinne.gif * * * http://www.FrankNStein.de/Smiley-Winken.gif

[himitsu]

Und täglich grüßt das Murmeltier http://www.FrankNStein.de/Smiley-Wolke.gif,

Zitat:

Zitat von Hansa (per PN)

Hi,

tja so ist das eben. Man lebt nur zweimal. :mrgreen: Allerdings ist da noch ein Haken in meinem Labor 8) :

Delphi-Quellcode:

Unit farb1;

Interface
  Uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls,
  ExtCtrls;

  Type TForm1 = Class(TForm)
    Memo1: TMemo;
    Timer1: TTimer;
    Procedure dunkler;
    Procedure heller;
    procedure Timer1Timer(Sender: TObject);
    procedure FormCreate(Sender: TObject);

    private
      i: integer;
      dunkelmodus: boolean;
  End;

  Var Form1: TForm1;

Implementation

{$R *.dfm}

Procedure TForm1.dunkler;
Var R, G, B: Byte;
  Farbe: TColor;
  HD: ShortInt;  { -100..0 = dunkler / 0..100 = heller  }

Begin
  HD := -10;
  Farbe := ColorToRGB(Color);
  R := (Farbe and $000000FF);
  G := (Farbe and $0000FF00) shr 8;
  B := (Farbe and $00FF0000) shr 16;
  R := R + (R * HD div 100);
  G := G + (G * HD div 100);
  B := B + (B * HD div 100);
  Color := RGB(R, G, B);
  memo1.lines.add('dunkler '+IntToStr (g));
End;

Procedure TForm1.heller;
Var R, G, B: Byte;
  Farbe: TColor;
  HD: ShortInt;  { -100..0 = dunkler / 0..100 = heller  }

Begin
  HD := 10;
  Farbe := ColorToRGB(Color);
  R := (Farbe and $000000FF);
  G := (Farbe and $0000FF00) shr 8;
  B := (Farbe and $00FF0000) shr 16;
(*
  R := R + ((255 - R) * HD div 100);
  G := G + ((255 - G) * HD div 100);
  B := B + ((255 - B) * HD div 100);
*)
  R := R + (R * HD div 100);
  G := G + (G * HD div 100);
  B := B + (B * HD div 100);
  Color := RGB(R, G, B);
  memo1.lines.add('***** heller *****  '+IntToStr (g));
End;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
(*
dunkelmodus := (i mod 10) < 5;
*)
  if not dunkelmodus then
(*
    heller
*)
  else begin
    dunkler;
    heller;
  end;
  dunkelmodus := not dunkelmodus;
  i := i + 1;
if i > 300000 then begin
  Timer1.Enabled := false;
  heller;
end;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  i := 0;
  dunkelmodus := true;
end;

End.

Ich habe die Buttons entfernt und lasse das ganze timergesteuert laufen. Ich mache alles heller oder dunkler, aber mit der Zeit wird alles immer dunkler.

Das sich der Wert bei einer häufigen Änderung einem mittleren Grau annähert ist schon richtig so, das ergiebt sich aus der rechenweises der Prozedur.

Nehmen wir mal einen Farbeanteil (z.B. Rot) heraus.
Da die Prozente immer vom aktuellen Farbwert zum Ende/Anfang der Scala hin gerechnet werden, ergeben +50% nicht die gleiche Änderung wie -50%.

Code:

dunkel                                                 hell
***** ***** ***** ***** ***** ***** ***** ***** ***** *****
                      2                     X      1
                         a              b
X = aktuelle Farbe
1 = +50%               a = erst +50% und danach -50%
2 = -50%               b = erst -50% und danach +50%

Wenn die Farbe also öfters geändert werden soll, ist es besser immer wieder von der Originalfarbe aus zu rechnen:

Delphi-Quellcode:

Function TForm1.FarbHelligkeit(Farbe: TColor; HD: ShortInt): TColor;
  { HD:   -100..0 = dunkler / 0..100 = heller }

  Var R, G, B: Byte;

  Begin
    Farbe := ColorToRGB(Farbe);
    R := (Farbe and $000000FF);
    G := (Farbe and $0000FF00) shr 8;
    B := (Farbe and $00FF0000) shr 16;
    If HD < 0 Then Begin
      R := Trunc(R + (R * HD / 100));
      G := Trunc(G + (G * HD / 100));
      B := Trunc(B + (B * HD / 100));
      {Form1.Memo1.Lines.Add('***** dunkler *****  ' + IntToStr(R));}
      Form1.Memo1.Lines.Add('***** dunkler *****  ' +
        IntToStr(R) + ':' + IntToStr(G) + ':' + IntToStr(B));
    End Else Begin
      R := Ceil(R + ((255 - R) * HD / 100));
      G := Ceil(G + ((255 - G) * HD / 100));
      B := Ceil(B + ((255 - B) * HD / 100));
      {Form1.Memo1.Lines.Add('***** heller *****   ' + IntToStr(R));}
      Form1.Memo1.Lines.Add('***** heller *****   ' +
        IntToStr(R) + ':' + IntToStr(G) + ':' + IntToStr(B));
    End;
    Result := RGB(R, G, B);
  End;

z.B.:

Delphi-Quellcode:

Color := FarbHelligkeit(clBtnFace, i);

In der geänderten Demo ist zu sehen, dass sich die Farbe etwas unsymetrisch ändert, was sich ja wieder aus der rechenweise ergiebt.

Das kann man aber änderen, in dem man eine andere Farbe nimmt (z.B. &7F7F7F), diese ist ja in der Mitte und es entsteht eine symetrische Änderung, oder den Änderungsbereich abändert (z.B. -10% bis +100% - das sieht zumindestens bei mir gut aus).

z.B.: -10% bis +100% =>
(-10%, -8%, -6%, -4%, -2%, 0%, +20%, +40%, +60%, +80%, +100%)
Das ergibt einen symetrischeren übergang.


http://www.delphipraxis.net/images/common/divider.jpg
http://www.FrankNStein.de/Smiley-Kuss.gif * * http://www.FrankNStein.de/Smiley-Spinne.gif * * * http://www.FrankNStein.de/Smiley-Winken.gif

[Keldorn]

Hallo
die ganze Sache geht recht einfach, Delphi unterstützt HLS in einer Graphutil unit, die steht nicht in der Hilfe und für Leute ohne Source sieht es schlecht aus.

da gibts ein paar umrechnungsfunktioen und dann die hier:

Zitat:

{ Given a color and a luminance change "n" this routine returns a color whose
luminace has been changed accordingly. }

function ColorAdjustLuma(clrRGB: TColorRef; n: Integer; fScale: BOOL): TColorRef;

so als kleines sinnloses Beispiel ;)

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
Var  i:integer;
     col:TColor;
begin
  col := rgb(255,100,50);
  for i:=-10 to 10 do
    begin
      Shape1.Brush.Color := ColorAdjustLuma(col,i*5,false);
      Application.ProcessMessages;
      sleep(50);
    end;
end;

mußt du mal n bischen rumprobieren

Mfg Frank