farbverlauf in %

[Garfield]

Dann sieh Dir dies mal an: http://efg2.com/Lab/Graphics/Colors/MaxwellTriangle.htm

[himitsu]

wenn du unbedingt über 3 Farben gehen willst, dann mußt du die Berechnung teilen
0%-50% Farbe1 > Farbe2
50-100% Farbe2 > Farbe2

aber Rot + Grün ergibt doch Gelb.
also sollte der Farbverlauf von Rot nach Grün auch über Gelb gehen?
(es sei denn ich hab mich verrechnet)
OK, 50% Rot + 50% Grün = 50% Gelb = dunkelgelb


Farbe = RGB(255 * Min(Prozent, 50) div 50, 255 * Min(100 - Prozent, 50) div 50, 0);

Delphi-Quellcode:

// eine Form mit Memo1:TMemo und Image1:TImage (.Stretch=true)

Procedure TForm1.FormCreate(Sender: TObject);
  Var Prozent: Integer;

  Begin
    Image1.Picture.Bitmap.Width  := 101;
    Image1.Picture.Bitmap.Height := 8;

    // jede Farbe gleichmäßig über den gesamten Bereich verteilt
    For Prozent := 0 to 100 do Begin
      Memo1.Lines.Add(Format('%d     R:%d  G:%d     F1:$%.8x   F2:$%.8x', [Prozent,
        {red}255 * Prozent div 100,
        {grün}255 * (100 - Prozent) div 100,
        {red}(255 * Prozent div 100) or {grün}(255 * (100 - Prozent) div 100 * $0100),
        RGB(255 * Prozent div 100, 255 * (100 - Prozent) div 100, 0)]));
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 0] :=
        RGB(255 * Prozent div 100, 255 * (100 - Prozent) div 100, 0);
    End;

    Memo1.Lines.Add('');

    // jede Farbe nur über den halben Bereich verteilt
    For Prozent := 0 to 100 do
      If Prozent <= 50 Then Begin
        Memo1.Lines.Add(Format('%d   R:%d G:%d   F1:$%.8x F2:$%.8x', [Prozent,
          {red}255 * Prozent div 50,
          {grün}255,
          {red}(255 * Prozent div 50) or {grün}(255 * $0100),
          RGB(255 * Prozent div 50, 255, 0)]));
        Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 3] :=
          RGB(255 * Prozent div 50, 255, 0);
      End Else Begin
        Memo1.Lines.Add(Format('%d   R:%d G:%d   F1:$%.8x F2:$%.8x', [Prozent,
          {red}255,
          {grün}255 * (100 - Prozent) div 50,
          {red}(255) or {grün}(255 * (100 - Prozent) div 50 * $0100),
          RGB(255, 255 * (100 - Prozent) div 50, 0)]));
        Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 3] :=
          RGB(255, 255 * (100 - Prozent) div 50, 0);
      End;

    Memo1.Lines.Add('');

    // jede Farbe nur über den halben Bereich verteilt - zusammengefaßt
    For Prozent := 0 to 100 do Begin
      Memo1.Lines.Add(Format('%d   R:%d G:%d   F1:$%.8x F2:$%.8x', [Prozent,
        {red}255 * Min(Prozent, 50) div 50,
        {grün}255 * Min(100 - Prozent, 50) div 50,
        {red}(255 * Min(Prozent, 50) div 50) or {grün}(255 * Min(100 - Prozent, 50) div 50 * $0100),
        RGB(255 * Min(Prozent, 50) div 50, 255 * Min(100 - Prozent, 50) div 50, 0)]));
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 6] :=
        RGB(255 * Min(Prozent, 50) div 50, 255 * Min(100 - Prozent, 50) div 50, 0);
    End;

    For Prozent := 0 to 100 do Begin
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 1] := Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 0];
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 2] := Self.Color;
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 4] := Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 3];
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 5] := Self.Color;
      Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 7] := Image1.Picture.Bitmap.Canvas.Pixels[Prozent, 6];
    End;
  End;

(*
object Form1: TForm1
  Left = 0
  Top = 0
  Caption = 'Form1'
  ClientHeight = 505
  ClientWidth = 337
  OnCreate = FormCreate
  object Image1: TImage
    Left = 8
    Top = 424
    Width = 321
    Height = 73
    Anchors = [akRight, akBottom]
    Stretch = True
  end
  object Memo1: TMemo
    Left = 8
    Top = 8
    Width = 321
    Height = 410
    Anchors = [akLeft, akTop, akRight, akBottom]
    ScrollBars = ssBoth
  end
end
*)

aber wie gesagt, alles nur ein bissl Mathematik ... hätt man sich auch selbst ausrechen können, bzw. selbst die passenden Formeln erstellen können

[lbccaleb]

Joa danke, genau das wars was ich brauchte...
Danke..

Umgewandelt noch in eine Funktion (Math in Uses aufnehmen):

Delphi-Quellcode:

function GetColor(Prozent: integer): COLORREF;
  begin
    Result := RGB(255 * Min(100 - Prozent, 50) div 50, 255 * Min(Prozent, 50) div 50, 0);
  end;

[mr_emre_d]

Delphi-Quellcode:

function Gradient( ACanvas: TCanvas;
  Pos: TRect; const FromColor, ToColor: Cardinal ): Boolean;
var
  x: Integer;
  NewColor: Cardinal;
  Percent: Single;
  rOP, gOP, bOP: Single;  // One Percent
begin
  Result := False;
  {Initialization}
  Pos.Right  := Pos.Right - Pos.Left;  // Right  = Width
  Pos.Bottom := Pos.Bottom - Pos.Top;  // Bottom = Height
  with ACanvas do
  begin
    rOP := (GetRValue(ToColor)-GetRValue(FromColor)) / Pos.Right;
    gOP := (GetGValue(ToColor)-GetGValue(FromColor)) / Pos.Right;
    bOP := (GetBValue(ToColor)-GetBValue(FromColor)) / Pos.Right;
    for x := 1 to Pos.Right do
    begin
      NewColor := RGB( GetRValue(FromColor)+Round(rOP*x),
        GetGValue(FromColor)+Round(gOP*x),
        GetBValue(FromColor)+Round(bOP*x) );
      Pen.Color := NewColor;
      MoveTo( Pos.Left+x, Pos.Top );
      LineTo( Pos.Left+x, Pos.Top+Pos.Bottom );
    end;
  end;
  Result := not Result;
end;

[himitsu]

@mr_emre_d: Zieh verfehlt, es sei denn du hast noch soeinene Funktion mit 3 Parametern.
(die Berechnung darin entspricht meiner ersten "falschen/ungewünschten" Formel)

Code:

[b]Function[/b] Gradient(ACanvas: TCanvas; Pos: TRect; const FromColor, [b]ThroughColor[/b], ToColor: TColor): Boolean;
  ...

Gradient(Canvas, Pos, clGreen, [b]clYellow[/b], clLime);

und wieso Cardinal? (TColor)

[mr_emre_d]

TColor = Cardinal
bzw TColor = 4 unsigned Bytes

Und ja, die habe ich (pfeile grad noch rum, kann sie aber demnächst posten)

[himitsu]

Zitat von mr_emre_d:

Und ja, die habe ich (pfeile grad noch rum, kann sie aber demnächst posten)

na dann werden mal sehn

Zitat:

TColor = Cardinal
bzw TColor = 4 unsigned Bytes

wen es schon einen Typen dafür gibt, warum dann diesen nicht verwenden?

PS: TColor ist nicht Cardinal (ein Glück, daß die Meißten die Bereichprüfung nicht aktiv haben)
  TColor = -$7FFFFFFF-1..$7FFFFFFF;

[mr_emre_d]

uupps ..
dann eben integer bzw signed 4 bytes

Edit:
Da hastes Himitsu:

Delphi-Quellcode:

function _inc(var x: Integer): Integer;
begin
  Result := x;
  inc(x);
end;

function Gradient2( ACanvas: TCanvas;
  Pos: TRect; const Colors: Array of Integer ): Boolean;
var
  x: Integer;
  NewColor: Integer;
  Percent: Single;
  rOP, gOP, bOP: Single;  // One Percent
  cOldID, cID: Integer;
  xPercent, OnePercent: Cardinal;
begin
  Result := False;
  {Initialization}
  Pos.Right  := Pos.Right  - Pos.Left;  // Right  = Width
  Pos.Bottom := Pos.Bottom - Pos.Top;  // Bottom = Height
  with ACanvas do
  begin
    cOldID     := -1;
    cID        := 0;
    xPercent   := High(Colors);
    if xPercent < 1 then
      Exit;
    OnePercent := Pos.Right div xPercent;
    for x := 1 to Pos.Right do
    begin
      if x-OnePercent >= OnePercent*cOLDID then
      begin
        cOldID := _inc(cID);
        rOP := (GetRValue(Colors[cID])-GetRValue(Colors[cOldID])) / OnePercent;
        gOP := (GetGValue(Colors[cID])-GetGValue(Colors[cOldID])) / OnePercent;
        bOP := (GetBValue(Colors[cID])-GetBValue(Colors[cOldID])) / OnePercent;
      end;
      NewColor := RGB(
        GetRValue(Colors[cOldID])+Round(rOP*(x mod OnePercent)),
        GetGValue(Colors[cOldID])+Round(gOP*(x mod OnePercent)),
        GetBValue(Colors[cOldID])+Round(bOP*(x mod OnePercent))
        );
      Pen.Color := NewColor;
      MoveTo( Pos.Left+x, Pos.Top );
      LineTo( Pos.Left+x, Pos.Top+Pos.Bottom );
    end;
  end;
  Result := not Result;
end;

[mr_emre_d]

Man könnte das ganze mit Scanline und co machen aber dazu hab ich grad keine Lust

[shmia]

Zitat von lbccaleb:

das Problem ist ja, das ich nicht alle Farben auf die selbe Art berechnen kann, ich will ja nur nen Übergang hinnbekommen von Rot zu Gelb zu Grün!

Hast du dir den Beitrag in der Code-Library wirklich gut angeschaut?
Ganz besonders die 2. Funktion:

Delphi-Quellcode:

// Farbe zwischen beliebig vielen vorgegebenen Farbwerten berechnen 
function ColorsBetween(colors:array of TColor; blend:Real):TColor;

Mit dieser Funktion kannst du die schönsten Farbverläufe berechnen.
Wenn du z.B. Rot nach Gelb zu Grün haben willst, dann wäre der Aufruf:
farbe := ColorsBetween([clRed, clYellow, clGreen], blendfaktor); Ein Farbübergang zwischen Rot und Grün ohne Farbmischung erreicht man z.B. indem man Grau als mittlere Farbe einsetzt:
farbe := ColorsBetween([clRed, clGrey, Green], blendfaktor); Ausserdem:
Also ich halte es für wichtig, dass man das Berechnen des Farbverlauf strikt vom Zeichen trennt.
Nur so kann man wirklich alle Möglichkeiten des Einfärben ausschöpfen.