halbtransparenten text auf TImage?

[Airblader]

Hi
Ich plage mich seit gestern damit rum, einen text mit einer bestimmten Deckkraft auf ein TImage zu zeichnen.
Bisher hab ich TextOut, nur da gibts keine transparenz.
Nunja...mir wurden 2 Möglichkeiten dargestellt:
- Pixelmanipulation
- AlphaBlending
Wobei eins dem anderem sehr ähnlich kommt.

Ich habe mal als "Grundgerüst" das zusammengebastelt:

Delphi-Quellcode:

function trans_text(const src, dest: TBitmap; opacity: real): Boolean; 
var 
w,h: integer; 
color, color2: Longint; 
r,g,b: byte; 
r2,g2,b2: byte; 
rr,gg,bb: byte; 
begin 
    for h:=0 to src.Height do 
    begin 
        for w:=0 to src.Width do 
        begin 
            color := ColorToRGB(src.Canvas.pixels[w,h]); 
            r := GetRValue(color); 
            g := GetGValue(color); 
            b := GetBValue(color); 
            color2 := ColorToRGB(dest.Canvas.pixels[w,h]); 
            r2 := GetRValue(color2); 
            g2 := GetGValue(color2); 
            b2 := GetBValue(color2); 


            rr := (r*r2) / 255; 
            gg := (g*g2) / 255; 
            bb := (b*b2) / 255; 

            dest.Canvas.pixels[w,h] := RGB(rr,gg,bb); 
        end; 
    end; 
end;

Nunja.
2 Probleme sind offensichtlich:

1. Die richtige Formel zur Manipulation
2. Nur Pixel manipulieren, die nich transparent sind

Übrigens:
src ist ein TImage, auf dem ich mit TextOut schreib, dest ein TImage, wo das ganze dann drauf soll (schon ein anderes bild vorhanden)
und nein, ich meine nicht den weissen kasten, den man mit bsClear wegbekommt.
ich meine, dass die schrift eben transparent werden soll, mit einstellbarer deckkraft (opacity)

Kann mir jmd helfen?

[Dax]

Erstmal Herzlich Willkommen in der DP!

Soweit ich weiss, gibt es nur 256 Levels der Transparenz, also ist Opacity: Real eher ein Byte.
Übrigens ist dein Code falsch: Die Transaprenz errechnet sich anders.

Die Grundlagen sind recht simpel: Du nimmst dir das src-Pixel, teilst den Farbwert durch 255 (da kommst du um Real nicht herum) und multiplizierst es dann mit Opacity. Dann machst du das selbe mit den Dest-Pixel, nur multiplizierst du mit (255-Opacity). Am Ende werden beide Werte (jeweils R, G und B) addiert, und du hast ein Transparentes Pixel.

[Airblader]

Erstmal Danke
Ja, war nur eben zusammengeschsutert..und wie gesagt: Dass die Formel falsch ist, war mir klar

Ich werde jetzt mal schauen was ich hinbekomm

air

[Dax]

Allerdings solltest du bei dem obigen Vorschlag beachten, dass du nicht weisst, welches Pixel bereits transparent war und nachher nicht weisst, welches Pixel welchen Transparenzwert besitzt.

[Airblader]

Zitat von Dax:

Allerdings solltest du bei dem obigen Vorschlag beachten, dass du nicht weisst, welches Pixel bereits transparent war und nachher nicht weisst, welches Pixel welchen Transparenzwert besitzt.

stimmt....das war das, was ich meinte.
aber wie frage ich ab, ob der aktuelle pixel bereits transparent ist?

hab es nun so:

Delphi-Quellcode:

function text_opacity(const src,dest: TBitmap; opacity: byte): Boolean;

[...]

function TForm1.text_opacity(const src,dest: TBitmap; opacity: byte): Boolean;
var
w,h: integer;
col, col2: Longint;
r1, g1, b1: byte;
r2, g2, b2: byte;
rr, gg, bb: byte;
begin
        for h:=0 to src.Height do
        begin
                for w:=0 to src.Width do
                begin
                        // Src:
                        col := ColorToRGB(src.Canvas.Pixels[w,h]); // Pixelfarbe
                        // Nun R G und B Wert holen:
                        r1 := GetRValue(col);
                        g1 := GetGValue(col);
                        b1 := GetBValue(col);

                        // Dest:
                        col2 := ColorToRGB(dest.Canvas.Pixels[w,h]); // Pixelfarbe
                        // Nun R G und B Wert holen:
                        r2 := GetRValue(col2);
                        g2 := GetGValue(col2);
                        b2 := GetBValue(col2);

                        // Neue RGB Werte errechnen
                        rr := ((r/255)*opacity) + (r2*(255-opacity));
                        gg := ((g/255)*opacity) + (g2*(255-opacity));
                        bb := ((b/255)*opacity) + (b2*(255-opacity));

                        // Pixel neu zeichnen
                        dest.Canvas.Pixels[w,h] := RGB(rr,gg,bb);
                end;
        end;
end;

air

P.S. Ne dumme Frage...ist mein Stil ordentlich?

[Dax]

Der Stil ist in Ordnung, allerdings musst du die x2-Werte auch noch durch 255 Teilen (fehlt das in meiner Erklärung?).
Und: Der einzige Weg, die Transparenz eines Pixel abzufragen, ist der Alphakanal, also die letzten 8 Bit bei einer 32Bit-Bitmap.

[Airblader]

hm hups..überlesen

OK....ich hab halt nur die 24er Bitmap...is ja klar.
D.h. es gibt keinen Weg?
Dann wäre der Rest ja auch umsonst *fg*

Mir fällt nur eine Möglichkeit ein:
Ich gebe beim Funktionsaufruf noch mit an, welche Farbe transparent sein soll.
D.h. ich habe bei der src-bmp eine Hintergrundfarbe, die je nach textfarbe anders ist.
Diese geb ich mit an.
Dann frag ich bevor ich manipuliere ab, ob der Pixel die gelieferte Farbe hat.

Wäre das eine Möglichkeit?

air

P.S.
Aktuell:

Delphi-Quellcode:

function TForm1.text_opacity(const src,dest: TBitmap; opacity: byte): Boolean;
var
w,h: integer;
col, col2: Longint;
r1, g1, b1: byte;
r2, g2, b2: byte;
rr, gg, bb: byte;
begin
        for h:=0 to src.Height do
        begin
                for w:=0 to src.Width do
                begin
                        // Src:
                        col := ColorToRGB(src.Canvas.Pixels[w,h]); // Pixelfarbe
                        // Nun R G und B Wert holen:
                        r1 := GetRValue(col);
                        g1 := GetGValue(col);
                        b1 := GetBValue(col);

                        // Dest:
                        col2 := ColorToRGB(dest.Canvas.Pixels[w,h]); // Pixelfarbe
                        // Nun R G und B Wert holen:
                        r2 := GetRValue(col2);
                        g2 := GetGValue(col2);
                        b2 := GetBValue(col2);

                        // Neue RGB Werte errechnen
                        rr := ((r/255)*opacity) + ((r2/255)*(255-opacity));
                        gg := ((g/255)*opacity) + ((g2/255)*(255-opacity));
                        bb := ((b/255)*opacity) + ((b2/255)*(255-opacity));

                        // Pixel neu zeichnen
                        dest.Canvas.Pixels[w,h] := RGB(rr,gg,bb);
                end;
        end;
end;

[Dax]

Du willst nur eine bestimmte Farbe transparent machen? Das geht ohne Probleme.

Ich sehe grade, in deinem Code ist noch ein Fehler: Der Operator / liefert Real-Ergebnisse zurück, du musst also bein den Pixelberechnungen den Fliesskommateil noch mit Trunc abschneiden.

[Airblader]

Nein.
Ich will ja einen schlichten Text auf ein Bild malen.
Da ich im 24er Bitmap die Transparenz aber nicht abfragen kann,
könnte ich doch in dem src-Bitmap als Hintergrundfarbe eine Farbe setzen, die ich beim Funktionsaufruf angebe.

So kann ich anstatt die Transparenz abzufragen, die gegebene Farbe abfragen.
Wenn der akt. Pixel dieser Farbe entspricht, bekommt der Pixel den Farbwert der Dest-Bitmap die diesem Pixel entspricht.

Hoffe nun geklärt zu haben

/edit:
mit Trunc:

Delphi-Quellcode:

function TForm1.text_opacity(const src,dest: TBitmap; opacity: byte): Boolean;
var
w,h: integer;
col, col2: Longint;
r1, g1, b1: byte;
r2, g2, b2: byte;
rr, gg, bb: byte;
begin
        for h:=0 to src.Height do
        begin
                for w:=0 to src.Width do
                begin
                        // Src:
                        col := ColorToRGB(src.Canvas.Pixels[w,h]); // Pixelfarbe
                        // Nun R G und B Wert holen:
                        r1 := GetRValue(col);
                        g1 := GetGValue(col);
                        b1 := GetBValue(col);

                        // Dest:
                        col2 := ColorToRGB(dest.Canvas.Pixels[w,h]); // Pixelfarbe
                        // Nun R G und B Wert holen:
                        r2 := GetRValue(col2);
                        g2 := GetGValue(col2);
                        b2 := GetBValue(col2);

                        // Neue RGB Werte errechnen
                        rr := (Trunc(r/255)*opacity) + (Trunc(r2/255)*(255-opacity));
                        gg := (Trunc(g/255)*opacity) + (Trunc(g2/255)*(255-opacity));
                        bb := (Trunc(b/255)*opacity) + (Trunc(b2/255)*(255-opacity));

                        // Pixel neu zeichnen
                        dest.Canvas.Pixels[w,h] := RGB(rr,gg,bb);
                end;
        end;
end;

[Dax]

Dann nützt dir der Opacity-Wert aber nichts mehr - weil du ja einfach nur die src-Pixel oder die Dest-Pixel kopierst, ohne Alpha-Blend.
Und: Die Funktion, die du suchst, gibt es schon. TBitmap.TransparentColor könnte dir als Anhaltspunkt dienen.

Ausserdem würde ich dir raten, erst am Ende der Transparenzrechnung zu runden, damit möglichst wenig Information verlorengeht.