nach StretchBlt schwarzer Hintergrund

[Helmi]

Hallo,

ich nutze zum skalieren von Bitmaps diese Function:

Delphi-Quellcode:

procedure Scale_Bitmap(var Bitmap: TBitmap; DestWidth, DestHeight: Integer;
  Smooth: Boolean = false);
var
  faktor      : Real;
  Width_Bitmap: Integer;
  Temp_Bitmap : TBitmap;
  Copy_Bitmap : TBitmap;

begin
  If Bitmap.Empty then
    exit;

  Temp_Bitmap := TBitmap.Create;
  Copy_Bitmap := TBitmap.Create;

  Width_Bitmap := Bitmap.Width div Count_Glyphs(Bitmap);

  If Width_Bitmap > DestWidth then
    begin
      faktor := DestWidth / Width_Bitmap;
      If (Bitmap.Height * faktor) > DestHeight then
        faktor := DestHeight / Bitmap.Height;
    end
  else
    begin
      faktor := DestHeight / Bitmap.Height;
      If (Width_Bitmap * faktor) > DestWidth then
        faktor := DestWidth / Width_Bitmap;
    end;

  try
    Copy_Bitmap.PixelFormat := pf24Bit;
    Copy_Bitmap.Assign(Bitmap);

    Temp_Bitmap.Width  := round(Bitmap.Width * faktor);
    Temp_Bitmap.Height := round(Bitmap.Height * faktor);

    If Smooth then
      SetStretchBltMode(Temp_Bitmap.Canvas.Handle, HALFTONE);

    StretchBlt(Temp_Bitmap.Canvas.Handle, 0, 0, Temp_Bitmap.Width, Temp_Bitmap.Height,
               Copy_Bitmap.Canvas.Handle, 0, 0, Copy_Bitmap.Width, Copy_Bitmap.Height,
               SRCCOPY);

    Bitmap.Assign(Temp_Bitmap);
  finally
    FreeAndNil(Temp_Bitmap);
    FreeAndNil(Copy_Bitmap);
  end;
end;

Das Vergrößern/Verkleinern funktioniert wunderbar - nur habe ich immer nach StretchBlt einen scharzen Hintergrund.
Das Original-Bitmap hat einen transparenten Hintergrund.

Ich habe schon versucht, die Transparenz-Properties von Bitmap auf Temp_Bitmap zu übertragen - aber geholfen hat es nichts.

Wie bekomm ich nach StrechBlt auch eine Transparenz?

Ich habe diesen Thread gefunden - aber leider hat er mir auch nicht geholfen

[BadenPower]

Hast Du schon versucht mit SetStretchBltMode einen anderen Modus zu nehmen?

Statt HALFTONE eventuell COLORONCOLOR.

Ich habe gerade noch gesehen, dass Du den Modus nur setzt, wenn Smooth true ist.

[Helmi]

Zitat:

Zitat von BadenPower (Beitrag 1290913)

Hast Du schon versucht mit SetStretchBltMode einen anderen Modus zu nehmen?

Statt HALFTONE eventuell COLORONCOLOR.

hab ich versucht, aber leider ohne Erfolg

Zitat:

Zitat von BadenPower (Beitrag 1290913)

Ich habe gerade noch gesehen, dass Du den Modus nur setzt, wenn Smooth true ist.

smooth ist true

[Namenloser]

Na, du setzt Pixelformat auf pf24Bit, und wunderst dich dann, dass du keinen Alpha-Kanal mehr hast? Die GDI ist allerdings generell nicht alphakanaltauglich, d.h. auch pf32Bit wird hier keine Besserung bringen.

Was du machen willst ist mit der GDI schlicht nicht möglich. Nimm Graphics32 oder GDI+.

[Helmi]

Zitat:

Zitat von Namenloser (Beitrag 1290915)

Na, du setzt Pixelformat auf pf24Bit, und wunderst dich dann, dass du keinen Alpha-Kanal mehr hast? Die GDI ist allerdings generell nicht alphakanaltauglich, d.h. auch pf32Bit wird hier keine Besserung bringen.

Was du machen willst ist mit der GDI schlicht nicht möglich. Nimm Graphics32 oder GDI+.

Wie macht man das mit GDI+?

[ConnorMcLeod]

Googlen, saugen und usen:

• GDIPAPI.pas
• GDIPOBJ.pas

Die gibt es meistens als ZIP-Package.

Als Objekte werden benötigt:
TGPGraphics
TGPImage
TColorMatrix
TGPImageAttributes
TGPMatrix

Leider habe ich meinen Code, in dem ich das gemacht habe, nicht zur Hand; hoffe das hilft trotzdem.

[Bernhard Geyer]

Oder händisch machen. Wir haben sowas für PNGs im einsatz.

[ConnorMcLeod]

Könnte auch mit Hilfe eines TPicture-Objektes gehen. Das verwende ich für transparente PNGs, allerdings ohne Manipulationen - nur malen. Wäre ein Experiment wert, ob es auch noch nach Dimensionsänderungen transparent malt.

[Helmi]

ich hab mir jetzt GUI+ von hier geladen

werd mich jetzt etwas damit auseinander setzen

bislang bin ich schon von der automatischen Umwandlung der Bild-Formate begeistert

[Medium]

Werd aber nicht ZU euphorisch, denn GDI+ ist seit ein paar Jahren schon abgekündigt. (Aber wenn mich nicht alles täuscht, ist die zumindest bis Win8.1 dabei, und für Win10 habe ich auch noch nichts gegenteiliges gehört. Ist halt nur nicht mehr garantiert und wird nicht mehr weiter entwickelt.)

[Helmi]

dann besser mit GUI+ gar nicht erst anfangen sondern gleich auf Graphics32 umsteigen?

[Harry Stahl]

Du kannst hier auch die Windows -Alphablend Funktion verwenden, die kann auch 32-Bit Bitmaps skalieren. Allerdings setzt die Funktion voraus, dass die Pixel dann Pre-multiplied sind.

[EWeiss]

Sieh doch mal ob dir das weiter hilft
http://www.delphipraxis.net/130998-a...-rotation.html

gruss

[Helmi]

ich hab mir jetzt mal Graphics32 angeschaut

hab jetzt aber nur die Möglichkeit gefunden, Bitmaps via TImage32 zu skalieren

Gibt es auch eine Möglichkeit das direkt im Bitmap32 zu machen?

[Neutral General]

Klappt denn dein ursprünglicher Code wenn du Pixelformat auf pf32Bit stellst?
Hab nämlich letztens noch genau das selbe gemacht und das hat funktioniert.

[Helmi]

Zitat:

Zitat von Neutral General (Beitrag 1291490)

Klappt denn dein ursprünglicher Code wenn du Pixelformat auf pf32Bit stellst?
Hab nämlich letztens noch genau das selbe gemacht und das hat funktioniert.

Leider nein

Ich hab alle drei Bitmaps (Bitmap, Temp_Bitmap, Copy_Bitmap) mal testweise auf pf32Bit gesetzt, aber ohne Verbesserung des Problemes

[edit]
Ich glaub ich weiss wo das Problem ist
Der schwarze Hintergrund ist schon im Original-Bitmap vorhanden

Das Original-Bitmap beinhaltet ein Icon

Test-Code:

Delphi-Quellcode:

procedure TForm3.Button2Click(Sender: TObject);
var
  S: String;
  Bitmap: TBitmap;
  Icon: TIcon;

begin
  S := ExtractFilePath(Application.ExeName);

  Bitmap := TBitmap.Create;
  Icon := TIcon.Create;

  try
//    Bitmap.LoadFromFile(S + 't.bmp');

    Icon.Handle := ExtractIcon(Application.Handle, PChar(Application.ExeName), 0);

    Icon.SaveToFile(S + 'test.ico');

    Bitmap.Assign(Icon);

    Bitmap.SaveToFile(S + 'origtest.bmp');

    Scale_Bitmap(Bitmap, 100, 200, true);

    Bitmap.SaveToFile(S + 'test.bmp');
  finally
    Bitmap.Free;
    Icon.Free;
  end;
end;

Schon origtest.bmp hat den schwarzen Hintergrund

[DeddyH]

Interessanter Artikel: http://parnassus.co/transparent-grap...re-gdi-part-1/, aber ehrlich gesagt wäre GDI+ wohl einfacher.

[Helmi]

Zitat:

Zitat von DeddyH (Beitrag 1291500)

Interessanter Artikel: http://parnassus.co/transparent-grap...re-gdi-part-1/, aber ehrlich gesagt wäre GDI+ wohl einfacher.

Dank dir!

ja - ich tendier auch zu GDI+

Aber wie zukunftssicher ist das?

[DeddyH]

Um das sicher zu erfahren müsstest Du wohl bei Microsoft anfragen.

[Neutral General]

Es gibt doch auch seit ein paar Delphi Versionen (Edit: Seit Delphi2010) ein Direct2D-Canvas was schon direkt mitgeliefert wird. Ist auch nicht schwerer als GDI+ (vllt sogar leichter) und DirectX wird wahrscheinlich so schnell nicht abgeschafft werden ;)

[Helmi]

Zitat:

Zitat von Neutral General (Beitrag 1291505)

Es gibt doch auch seit ein paar Delphi Versionen (Edit: Seit Delphi2010) ein Direct2D-Canvas was schon direkt mitgeliefert wird. Ist auch nicht schwerer als GDI+ (vllt sogar leichter) und DirectX wird wahrscheinlich so schnell nicht abgeschafft werden ;)

Ich hab mit Direct2DCanvas jetzt mal was gebastelt:

Delphi-Quellcode:

procedure Scale_Bitmap(var Bitmap: TBitmap; DestWidth, DestHeight: Integer);
var
  faktor      : Real;
  Width_Bitmap: Integer;
  D2DCanvas   : TDirect2DCanvas;
  Temp_Bitmap : TBitmap;
  Rect        : TRect;

begin
  If Bitmap.Empty then
    exit;

  Temp_Bitmap := TBitmap.Create;

  Width_Bitmap := Bitmap.Width div 1; //Count_Glyphs(Bitmap);

  If Width_Bitmap > DestWidth then
    begin
      faktor := DestWidth / Width_Bitmap;
      If (Bitmap.Height * faktor) > DestHeight then
        faktor := DestHeight / Bitmap.Height;
    end
  else
    begin
      faktor := DestHeight / Bitmap.Height;
      If (Width_Bitmap * faktor) > DestWidth then
        faktor := DestWidth / Width_Bitmap;
    end;

  Rect.Left   := 0;
  Rect.Top    := 0;
  Rect.Width  := round(Bitmap.Width * faktor);
  Rect.Height := round(Bitmap.Height * faktor);

  Temp_Bitmap.Width := Rect.Width;
  Temp_Bitmap.Height := Rect.Height;

  D2DCanvas := TDirect2DCanvas.Create(Temp_Bitmap.Canvas, Rect);
  D2DCanvas.BeginDraw;

  try
    D2DCanvas.StretchDraw(Rect, Bitmap);

    Bitmap.Assign(Temp_Bitmap);
  finally
    D2DCanvas.EndDraw;
    FreeAndNil(D2DCanvas);
    FreeAndNil(Temp_Bitmap);
  end;
end;

[edit]
Mist - jetzt hab ich anstatt eines schwarzen Hintergrundes einen weissen Hintergrund
:-(

[HolgerX]

Hallo..

Habe mal ne ganz blöde Frage:

Seit wann hat ein TBitmap Transparenz?

Meines Wissens wird eine Transparenz erst vom TImage erzeugt,indem es eine definierte Farbe (zumeist aus der Ecke des Bitmaps) bei der Visualisierung transparent darstellt, aber mit ist nicht bekannt, das TBitmap überhaupt eine Transparenz hat.

Wenn Du Transparenz nutzen willst, musste wohl ein Image-Format wählen, welches das kann, wie z.B. GIF oder PNG..
..

Ein Icon hat Transparenz und beim Assign zu einem TBitmap wird hier eine Füllfarbe verwendet, da TBitmap keins hat, in deinem Beispiel schwarz!

[Harry Stahl]

[QUOTE=Helmi;1291491
Schon origtest.bmp hat den schwarzen Hintergrund[/QUOTE]

Du kannst die Beschaffenheit des Icons näher erkunden, indem Du das Icon oder die erzeugte Bitmap einfach mal in ein Grafikprogramm lädst, das Icons oder auch 32-bit-Bitmaps anzeigen kann. Ich habe mal das Icon und das Bitmap in mein Pixpower-Programm geladen und man erkennt, dass z.B. das Standard-Delphi-Icon einen schwarzen Hintergrund hat und bei diesen schwarzen Pixeln aber das Alpha-Pixel auf Null gesetzt ist (vgl. Anlage 1). Daneben sind noch teiltransparente Pixel vorhanden, also wo das Alpha-Pixel einen Wert zwischen 1 und 254 hat.

Das gleiche Bitmap wird aber in Programmen, welche keine 32-Bit-Bitmaps (richtig) anzeigen können, mit schwarzem Hintergrund angezeigt, z.B. Die Windows Fotoanzeige (vgl. Anlage 2).

Dann weiß Du nämlich schon mal, was am Ende Deiner Bemühungen als richtiges Ergebnis dabei rauskommen soll.

[Harry Stahl]

Zitat:

Zitat von HolgerX (Beitrag 1291527)

Hallo..

Habe mal ne ganz blöde Frage:

Seit wann hat ein TBitmap Transparenz?

Meines Wissens wird eine Transparenz erst vom TImage erzeugt,indem es eine definierte Farbe (zumeist aus der Ecke des Bitmaps) bei der Visualisierung transparent darstellt, aber mit ist nicht bekannt, das TBitmap überhaupt eine Transparenz hat.

Wenn Du Transparenz nutzen willst, musste wohl ein Image-Format wählen, welches das kann, wie z.B. GIF oder PNG..
..

Ein Icon hat Transparenz und beim Assign zu einem TBitmap wird hier eine Füllfarbe verwendet, da TBitmap keins hat, in deinem Beispiel schwarz!

Ein 32-Bit-Bitmap hat neben den RGB-Pixeln einen Alpha-Kanal (das A-Pixel), wo man einen Transparenzwert drin speichern kann. Allerdings können nicht alle Programme mit dem 32-Bit-Bitmap so richtig umgehen.

Der "Trick" mit der Ecke des Bitmaps (i.d.R. Bitmaps mit 24-Bit oder weniger) wird (z.B. auch in Delphi) verwendet, um eine bestimmte Farbe transparent erscheinen zu lassen. Damit kann man aber z.B. keine transparenten Verläufe darstellen, sondern nur eben eine Farbe transparent schalten.

[Helmi]

Zitat:

Zitat von Harry Stahl (Beitrag 1291531)

Das gleiche Bitmap wird aber in Programmen, welche keine 32-Bit-Bitmaps (richtig) anzeigen können, mit schwarzem Hintergrund angezeigt, z.B. Die Windows Fotoanzeige (vgl. Anlage 2).

mmh - diese Aussage find ich interessant

Ich muss, glaub ich, noch etwas über das Verarbeiten nach dem Skalieren erzählen

Das skalierte Bitmap wird danach in einem StringGrid angezeigt und zwar mittels diesem Code:

Delphi-Quellcode:

StringGrid.Canvas.Draw(Rect.Left, Rect.Top, Bitmap);

Und da bekomm ich immer den Hintergrund mit

[edit]
Ich hab jetzt nochmal meinen Ausgangscode modifiziert und hab diese Zeilen eingefügt
und eigenartigerweise funktionierts jetzt

Delphi-Quellcode:

Bitmap.TransparentColor := Bitmap.Canvas.Pixels[Bitmap.Width, Bitmap.Height];
Bitmap.Transparent := true;

[HolgerX]

Zitat:

Zitat von Harry Stahl (Beitrag 1291533)

Zitat:

Zitat von HolgerX (Beitrag 1291527)

Hallo..

Habe mal ne ganz blöde Frage:

Seit wann hat ein TBitmap Transparenz?

Meines Wissens wird eine Transparenz erst vom TImage erzeugt,indem es eine definierte Farbe (zumeist aus der Ecke des Bitmaps) bei der Visualisierung transparent darstellt, aber mit ist nicht bekannt, das TBitmap überhaupt eine Transparenz hat.

Wenn Du Transparenz nutzen willst, musste wohl ein Image-Format wählen, welches das kann, wie z.B. GIF oder PNG..
..

Ein Icon hat Transparenz und beim Assign zu einem TBitmap wird hier eine Füllfarbe verwendet, da TBitmap keins hat, in deinem Beispiel schwarz!

Ein 32-Bit-Bitmap hat neben den RGB-Pixeln einen Alpha-Kanal (das A-Pixel), wo man einen Transparenzwert drin speichern kann. Allerdings können nicht alle Programme mit dem 32-Bit-Bitmap so richtig umgehen.

Der "Trick" mit der Ecke des Bitmaps (i.d.R. Bitmaps mit 24-Bit oder weniger) wird (z.B. auch in Delphi) verwendet, um eine bestimmte Farbe transparent erscheinen zu lassen. Damit kann man aber z.B. keine transparenten Verläufe darstellen, sondern nur eben eine Farbe transparent schalten.

OK, dann kann die procedure Scale_Bitmap(var Bitmap: TBitmap; DestWidth, DestHeight: Integer);

u.a. von Helmi nur dann funktionieren, wenn
A) das QuellBitmap 32Bit hat
B) Temp_Bitmap entweder ebenfalls nach dem create auf 32bit gesetzt wird oder von Delphi direkt auf 32bit gesetzt ist..

Wenn ich mich recht entsinne macht Delphi als default nen 24bit, da u.a. ältere Delphi-Versionen mit 32bit garnicht umgehen konnten..

[Harry Stahl]

OK, wenn das Bitmap richtig skaliert wurde und die Transparenz richtig beibehalten wurde, dann sollte die Anzeige damit korrekt möglich sein.

Wahrscheinlich ist Deine Skalierungsmethode noch nicht richtig.

Ich habe zwar die Skalierung von 32-Bit Bitmaps in meinem Bildbearbeitungsprogramm integriert, leider kann ich hier keine fertige Lösung posten, da ich für die Skalierung selber verschiedene Methoden verwende und hier ein Mix zwischen eigenen Source-Code und kommerziell erworben Parts besteht.

Generell habe ich es so gelöst, dass ich von dem 32-Bit-Bitmap ein 24-Bit Graustufen-Bild (als Hilfsbitmap) aus dem Alpha-Kanal erstelle. Dann wird das 32-Bit auf ein 24-Bit gesetzt und z.B. mit Stretchblt (oder eben anderen Methoden) skaliert. Auch das Graufstufen-Bild wird dann mit der gleichen Methode skaliert. Dann wird das skalierte 24-Bitmap auf 32-Bit gesetzt und der Alpha-Kanal aus dem skalierten Graustufenbild erzeugt.

[Harry Stahl]

Zitat:

Zitat von Helmi;1291534
[edit

Ich hab jetzt nochmal meinen Ausgangscode modifiziert und hab diese Zeilen eingefügt
und eigenartigerweise funktionierts jetzt

Delphi-Quellcode:

Bitmap.TransparentColor := Bitmap.Canvas.Pixels[Bitmap.Width, Bitmap.Height];
Bitmap.Transparent := true;

Wobei dann noch zu prüfen wäre, ob nur die schwarzen Pixel jetzt einfach transparent sind und die teiltransparenten Pixel noch Ihre Teiltransparenz haben oder deren Alpha-Wert einfach auf 255 = voll Sichtbar gesetzt worden sind.

[Helmi]

Zitat:

Zitat von Harry Stahl (Beitrag 1291540)

Zitat:

Zitat von Helmi;1291534
[edit

Ich hab jetzt nochmal meinen Ausgangscode modifiziert und hab diese Zeilen eingefügt
und eigenartigerweise funktionierts jetzt

Delphi-Quellcode:

Bitmap.TransparentColor := Bitmap.Canvas.Pixels[Bitmap.Width, Bitmap.Height];
Bitmap.Transparent := true;

Wobei dann noch zu prüfen wäre, ob nur die schwarzen Pixel jetzt einfach transparent sind und die teiltransparenten Pixel noch Ihre Teiltransparenz haben oder deren Alpha-Wert einfach auf 255 = voll Sichtbar gesetzt worden sind.

Und wie stellt man das an?

Aber ich glaub es muss so lauten:

Delphi-Quellcode:

Bitmap.TransparentColor := Bitmap.Canvas.Pixels[Bitmap.Width - 1, Bitmap.Height - 1];

[Harry Stahl]

Zitat:

Zitat von Helmi (Beitrag 1291542)

Und wie stellt man das an?

Du siehst vorher nach (wie oben von mir beschrieben), ob das Icon teiltransparente Pixel hat (wie z.B. das Standard-Delphi-Icon), skalierst die Grafik mit Deiner Funktion und kontrollierst das Ergebnis, indem Du die 32-Bit-Ergebnis-Bitmap als BMP-Datei speicherst und in einen Editor lädst und dort schaust, ob die Teiltransparenz erhalten geblieben ist.

Mit dem bloßen Auge kannst Du es der Grafik ja nicht ansehen, da kann z.B. auf einem weißen Hintergrund ein teiltransparentes Schwarz ja wie ein voll sichtbares Grau aussehen. Du musst dann halt kontrollieren, ob einige Pixel im Alpha-Bit einen Wert zwischen 1 und 254 haben (0= Pixel ist unsichtbar bzw. voll transparent, 255= Pixel ist voll sichtbar bzw. hat 100% Deckkraft).

[Sherlock]

Ich skaliere nur noch mit dem http://docwiki.embarcadero.com/VCL/X...hics.TWICImage.

Beispiel einer proportionalen Skalierung:

Delphi-Quellcode:

procedure ResizeImage(aWICImage: TWICImage; NewWidth:Integer);
var
  scale: IWICBitmapScaler;
  wicBitmap: IWICBitmap;
  newHeight:Integer;
  faktor:Double;
begin
  if Assigned(aWICImage) then
  begin
    faktor := NewWidth / aWICImage.Width;
    newHeight := Round(aWICImage.Height  * faktor);

    aWICImage.ImagingFactory.CreateBitmapScaler(scale);
    scale.Initialize(aWICImage.Handle, NewWidth, NewHeight, WICBitmapInterpolationModeFant);
    aWICImage.ImagingFactory.CreateBitmapFromSourceRect(scale, 0,0,NewWidth, NewHeight, wicBitmap);
    if Assigned(wicBitmap) then
      aWICImage.Handle := wicBitmap;
  end;
end;

Sherlock

[Helmi]

Zitat:

Zitat von Sherlock (Beitrag 1291613)

Ich skaliere nur noch mit dem http://docwiki.embarcadero.com/VCL/X...hics.TWICImage.

Gut regergiert, Sherlock! 8-)

eine interessante Funktion

Ich hab das mal für normale Bitmaps (testweise) umgestrickt:

Delphi-Quellcode:

procedure ResizeImage(Bitmap: TBitmap; NewWidth:Integer);
var
  WICImage : TWICImage;
  WICBitmap: IWICBitmap;
  scale    : IWICBitmapScaler;
  newHeight: Integer;
  faktor   : Double;

begin
  If not Assigned(Bitmap) then
    exit;

  WICImage := TWICImage.Create;

  WICImage.Assign(Bitmap);

  try
    faktor    := NewWidth / WICImage.Width;
    newHeight := round(WICImage.Height * faktor);

    WICImage.ImagingFactory.CreateBitmapScaler(scale);

    scale.Initialize(WICImage.Handle, NewWidth, NewHeight, WICBitmapInterpolationModeFant);

    WICImage.ImagingFactory.CreateBitmapFromSourceRect(scale, 0,0,NewWidth, NewHeight, WICBitmap);

    If Assigned(WICBitmap) then
      WICImage.Handle := WICBitmap;

    Bitmap.Assign(WICImage);
  finally
//    WICImage.Free;
  end;
end;

[Harry Stahl]

Stimmt, das geht auch mit der Windows Imaging Component (WIC), die Transparenz bleibt da erhalten.

Kleiner Wermutstropfen ist dabei, dass WIC unter Windows erst ab Vista standardmäßig im System dabei ist. Für XP muss der Anwender Deines Programms das auf dem System evtl. nachinstallieren (allerdings ab Servicepack xp3 ist es wohl schon dabei).

Aber allmählich ist die Unterstützung für XP vielleicht sowieso nicht mehr so wichtig...