Verlauf mit "gewichteter" Farbe mittels Log?

[Satty67]

Denke der Code von C# ist einfach nach Delphi portierbar. Auch der Formel-Ansatz von Medium ist dank der besseren Range-Kontrolle ein guter Weg.

Bin heute Abend grillen (danach sicher zu faul), aber werde das ganze später mal in Delphi 5 kompatiblen Code umschreiben

[Pfoto]

@Satty67:
Ddas sieht schon sehr nahe zu dem aus, wie ich das gedachte hatte.
Der einzige Nachteil ist, das man ab einer gewissen Stelle den Verlauf
"umbrechen" sieht, hin zur anderen Farbe (aber nur, wenn man größere
Prozentwerte nimmt).
Wenn Du Lust hat, den C#-Code von Julius nach Pascal zu übertragen,
wäre das klasse. Es ist auch nicht so dringend, es gibt da noch genügend
andere Baustellen in meinem Programm...

@Julius:
Ich hatte ja auch schon versucht, den Hinweis von Medium umzusetzen,
aber bei mir kam leider nichts gescheites raus. Danke für deinen Code!

Gruß
Jürgen

[jfheins]

Ich hab die die wichtigen Teile nochmal kommentiert

Code:

        private void pictureBox1_Paint(object sender, PaintEventArgs e) 
        { 
            double pos = 0; // Position entlang der Paintbox/Picturebox im Intervall 0..1
            double amount = 0; // Menge der ersten Farbe - soll also von links 1 (= 100%) nach rechts 0 werden
            Color tempColor; // Wird die Farbe enthalten, an der Position an der wir gerade sind
            Pen myPen = new Pen(col1); // Braucht man in Delphi nicht

            for (int i = 0; i < pictureBox1.Width; i++) 
            { 
                pos = (double)i / (pictureBox1.Width - 1);
// pos errechnen. Wenn i = 0 dann pos = 0 Wenn i = (Width-1) dann pos = 1 

                amount = 1 - Math.Pow(pos, potenz); 
// Menge der Farbe ausrechnen. Dazu potenzieren wir die Position (Intervall 0..1) mit der Potenz.
// Es kommt garantiert wieder etwas aus dem Intervall 0..1 raus.
// Da die Position von 0 nach 1 läuft, nehmen wir 1 - Math.pow() um die Menge der ersten Farbe rauszubekommen.
                tempColor = MixColors(col1, col2, amount); 
// Mischt die beiden Farben zusammen. Code siehe unten
                myPen.Color = tempColor; 
// Farbe merken
                e.Graphics.DrawLine(myPen, new Point(i, 0), new Point(i, pictureBox1.Height - 1)); 
// Und eine vertikale Linie an der Position zeichnen an der wir gerade sind.
// (Wir bewegen uns horizontal und zeichnen dann immer eine 1px breite Linie von oben nach unten)
            } 
        } 

        private Color MixColors(Color col1, Color col2, double amount) 
        { 
            if (amount < 0 || amount > 1) 
                throw new ArgumentOutOfRangeException("amount"); 
// Bitte tauschen Sie die FPU oder den Programmierer aus - einer von beiden macht Mist :-P

            byte R = (byte)(col1.R * amount + col2.R * (1 - amount)); 
            byte G = (byte)(col1.G * amount + col2.G * (1 - amount)); 
            byte B = (byte)(col1.B * amount + col2.B * (1 - amount)); 
// Farben einzeln Mischen. Farbe := Farbe1 mal Menge + Farbe2 mal (1 - Menge)
            return Color.FromArgb(R, G, B); 
        }

Ich hoffe das ist verständlich

[Satty67]

Ja, ist verständlich. Basiswissen zu den anderen Dialekten besteht und bei C# darf man sich ja über die bekannte Klassenhierarchie freuen.

Das Ergenbis ist nochmal besser als meine Version (ohne Vertikal, etwas Arbeit soll Pfoto ja auch noch haben) :

Delphi-Quellcode:

procedure FillGradient(Canvas: TCanvas; FromClr, ToClr: TColor; aRect: TRect; Potenz : Double);

  function MixColors(FromColor, ToColor: TColor; Amount: Double): TColor;
  type
    TRGB = packed record
      R,G,B,P : Byte;
    end;
  var
    FromClr, ToClr, ResultClr : TRGB;
  begin
    if (Amount < 0) or (Amount > 1) then Exit;

    FromClr := TRGB( ColorToRGB(FromColor) );
    ToClr := TRGB( ColorToRGB(ToColor) );

    ResultClr.R := Round( FromClr.R * Amount + ToClr.R * (1 - Amount) );
    ResultClr.G := Round( FromClr.G * Amount + ToClr.G * (1 - Amount) );
    ResultClr.B := Round( FromClr.B * Amount + ToClr.B * (1 - Amount) );
    ResultClr.P := 0;

    Result := TColor(ResultClr);
  end;

var
  aPos, Amount : Double;
  TmpClr : TColor;
  i, width : Integer;
begin
  width := aRect.Right - aRect.Left;

  for i := 0 to width-1 do begin

    aPos := i / (width-1);
    Amount := 1 - Power(aPos, Potenz);
    TmpClr := MixColors(FromClr, ToClr, Amount);

    Canvas.Pen.Color := TmpClr;
    Canvas.MoveTo(aRect.Left + i, aRect.Top);
    Canvas.LineTo(aRect.Left + i, aRect.Bottom);

  end;
end;

Mir hat's Spass gemacht und meine Beispiel-Bibliothek hat eine tolle Funktion zum Erzeugen von Verläufen dazu bekommen.

€:
Wenn man beide Versionen nebeneinander anzeigen lässt, sieht man den Unterschied gut. In meiner Version mit der harten Verlaufsgrenze sieht man eben diese Grenze sehr gut, dafür ist der Verlauf immer über den ganzen Farbbereich.

Die Version mit der Potenzierung hat immer ein sehr weiche Grenze, aber dafür im Extrem auch einen großen fast reinen Farbbereich.

(siehe auch Bild in der Anlage)

Einen Tod muss man aber sterben, denn solange die Einzel-Farben nur Byte Werte sind, wird sich ein Verlauf auf 255 Werte beschränken. Dittering wäre dann noch eine Möglichkeit.

[Pfoto]

Hallo ihr Beiden,

ich danke Euch sehr für Eure Mühe!
Jetzt ist es ja genau so wie es in meiner Vorstellung war.

Gruß
Jürgen