Konvertieren eines TBitmap zu einem TPngImage tut später komische Dinge

[Der schöne Günther]

Szenario: Ich habe eine

Delphi-Quellcode:

TImage

-Komponente auf ein Formular geworfen. Es ist ein Png-Bild. Da das Standard-Resizen eines

Delphi-Quellcode:

TImage

ziemlich hässlich aussieht wollte ich es noch einmal schöner berechnen wenn der Benutzer mit dem Resizing aufgehört hat.

Das tue ich:
(Lokale Objekte zerstören habe ich weggelassen)

Delphi-Quellcode:

uses GraphUtil;

// originalImage ist ein TPngImage was das hochaufgelöste Bild enthält
// imageComponent ist die TImage-Komponente auf dem Formular
procedure TFrame6.smoothScaledImage(const imageComponent: TImage);
var
   originalBitmap: TBitmap; // Bitmap copy von originalImage (TPngImage)
   resultingBitmap: TBitmap; // Bitmap-Ergebnis von GrpahUtils.ScaleImage
   pngImage: TPngImage;   // PNG-Konvertierung von resultingBitmap

   scaleAmount: Double;
begin
   originalBitmap := TBitmap.Create();
   originalBitmap.SetSize(originalImage.Width, originalImage.Height);
   originalBitmap.Canvas.Draw(0, 0, originalImage);

   resultingBitmap := TBitmap.Create();
   resultingBitmap.SetSize(imageComponent.Width, imageComponent.Height);
   resultingBitmap.Transparent := True; // Das hier ist böse

   if imageComponent.Height < imageComponent.Width then
      scaleAmount := imageComponent.Height / originalImage.Height
   else
      scaleAmount := imageComponent.Width / originalImage.Width;

   GraphUtil.ScaleImage(originalBitmap, resultingBitmap, scaleAmount);

   pngImage := TPngImage.Create();
   pngImage.Assign(resultingBitmap);
   imageComponent.Picture.Assign(pngImage);
end;

Im Klartext:

1. Ich kopiere das originalImage in ein Bitmap
2. Ich erstelle ein transparentes Bitmap für die TImage-Komponente
3. Ich skaliere das 1. Bitmap auf die Größe des 2. und schreibe es dort hinein
4. Ich konvertiere das 2. Bitmap wieder nach Png (TPngImage)
5. Das Png-Image wird dem Picture der Formular-Komponente zugewiesen

Nun das Problem:
Die Zeile

Delphi-Quellcode:

resultingBitmap.Transparent := True;

sorgt dafür dass später das konvertierte PNG-Bild auf dem Formular flackert wie Bolle. Auch das Skalieren sieht stellenweise extrem komisch aus.

Kann jemand erkennen, warum das so ist? Irgendwas ist mit dem erzeugten PNG-Bild falsch. Würde ein eingestelltes Beispielprojekt helfen?

[Uwe Raabe]

Du könntest alternativ mal die Funktion

Delphi-Quellcode:

ConvertToPNG

aus der Unit

Delphi-Quellcode:

PngFunctions

der PngComponents versuchen. Das dort verwendete Verfahren ist etwas anders implementiert als das in

Delphi-Quellcode:

TPngImage.Assign

. Ob das allerdings besser ist bzw. dein Problem löst, kann ich nicht sagen.

[samso]

Mir ist Dein "transparentes Bitmap" aufgestoßen. Meines Wissens gibt es so etwas doch gar nicht. Um die Transparenz zu simulieren wurde bei meinen Delphis immer ein bestimmtes Pixel (oben links?) genommen und dessen Farbe wurde dann zum Berechnen der Transparenz benutzt. Wenn Du das Bild skalierst werden diverse Mischfarben erzeugt. In der Folge sind dann die "transparenten" Pixel zumeist wild über das Bild verstreut. Um eine echte Transparenz zu erzeugen braucht man ein Bild das eine entsprechende Maske enthält (wie z.B. Icons) oder eine wirklich eindeutige Transparenz-Farbe.

[Bernhard Geyer]

Das Transparenzpixel ist links unten.

Und auch beim Skalieren kann man die Semitransparenz des PNG erhalten.
Unter http://cc.embarcadero.com/Item/25631 gibts Quellcode die das (Qualität müsstest du selbst bewerten) Skalieren auch für PNGs mit beibehalten der Semitransparenz durchführt.

[Sherlock]

Unter Windows? Bleib bei dem PNG, schreib es in ein TWICImage und skaliere das.
http://docwiki.embarcadero.com/VCL/e...hics.TWICImage

Sherlock

[Der schöne Günther]

Mit dem TWicImage hatte ich es schon versucht, war aber zu dumm dafür. Deine flapsige Antwort ließ es so trivial klingen dass ich es nochmal versuchen musste. Und ich glaube, jetzt habe ich's:
:bounce1:

Delphi-Quellcode:

uses Winapi.Wincodec;

procedure TForm5.recalcImageNew();
const
   interpolationMode: WICBitmapInterpolationMode = WICBitmapInterpolationModeFant;
var
   wicImage: TWICImage;
   bitmapScaler: IWicBitmapScaler;

   aspectRatio: Double;
   newSize: TPoint;
begin
   wicImage := TWICImage.Create();
   wicImage.ImageFormat := TWICImageFormat.wifPng;
   wicImage.LoadFromFile('Zeichnung1.png');

   aspectRatio := 1.0;
   if image1.Width < image1.Height then
      aspectRatio := image1.Width / wicImage.Width
   else
      aspectRatio := image1.Height / wicImage.Height;
   newSize.X := Round( wicImage.Width * aspectRatio);
   newSize.Y := Round( wicImage.Height * aspectRatio);


   wicImage.ImagingFactory.CreateBitmapScaler(bitmapScaler);
   bitmapScaler.Initialize(wicImage.Handle, newSize.X, newSize.Y, interpolationMode);
   wicImage.Handle := IWICBitmap(bitmapScaler);

   image1.Picture.Assign(wicImage);
end;

Das sieht gut aus und flackert nicht. Vielen Dank für die Hilfe und den seelischen Beistand.


Warum aber der obige Quellcode so merkwürdige Ergebnisse produziert habe ich nicht im geringsten verstanden :gruebel:

[Sherlock]

Ich weiss doch, daß man Dir nicht mit Details kommen muss ;)

Ich habs so gemacht (proportionalies Resize):

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;

Wie Du siehst, weitgehend gleich.
Sherlock

[Redeemer]

Zitat:

Zitat von samso (Beitrag 1282709)

Mir ist Dein "transparentes Bitmap" aufgestoßen. Meines Wissens gibt es so etwas doch gar nicht. Um die Transparenz zu simulieren wurde bei meinen Delphis immer ein bestimmtes Pixel (oben links?) genommen und dessen Farbe wurde dann zum Berechnen der Transparenz benutzt. Wenn Du das Bild skalierst werden diverse Mischfarben erzeugt. In der Folge sind dann die "transparenten" Pixel zumeist wild über das Bild verstreut. Um eine echte Transparenz zu erzeugen braucht man ein Bild das eine entsprechende Maske enthält (wie z.B. Icons) oder eine wirklich eindeutige Transparenz-Farbe.

Es gibt transparente Bitmaps, die funktionieren allerdings nur in TImageList mit ColorDepth := cd32Bit. Man muss dazu einer TBitmap ein TPNGImage assignen und das ganze in eine TImageList packen (AddMasked mit Mask clNone). Es scheint so, als würden halbtransparente Flächen während TBitmap.Assign gegen Schwarz geglättet, sprich sie werden z.T. deutlich dunkler. Zugriff auf Canvas killt die Transparenz von TBitmap, also muss man die Scanline kopieren, dann hat man das Problem nicht mehr:

Delphi-Quellcode:

function PNGToBMP(PNG: TPngImage; Free: Boolean = False): Graphics.TBitmap;
var
  i, j: Integer;
begin
  Result := Graphics.TBitmap.Create;
  Result.Assign(PNG);
  if PNG.Header.ColorType = COLOR_RGBALPHA then
  for i := 0 to PNG.Height - 1 do
  for j := 0 to PNG.Width - 1 do
  begin
    TByteArray(Result.ScanLine[i]^)[j*4] := TByteArray(PNG.Scanline[i]^)[j*3];
    TByteArray(Result.ScanLine[i]^)[j*4+1] := TByteArray(PNG.Scanline[i]^)[j*3+1];
    TByteArray(Result.ScanLine[i]^)[j*4+2] := TByteArray(PNG.Scanline[i]^)[j*3+2];
  end;
  if Free then
  PNG.Free;
end;

32-Bit-Bitmaps anzeigen (TPicture.Assign() oder TPicture.Bitmap zuweisen) glättet gegen weiß und tut andere seltsame Dinge. Also nur benutzen, um sie in TImageList zu packen.