Delphi-PRAXiS - Delphi Wie skaliert man am besten die Grafiken einer TPngImageList?

Um hohe Display-Auflösungen zu unterstützen, habe ich meine Anwendungen bereits mit dem korrekten Manifest versehen und in Kleinstarbeit alles so angepasst, dass alle Komponenten, Abstände, usw. auch bei 125% … 200% gut aussehen.

Das einzige verbleibende Problem sind die Menü-Grafiken, die leider nicht skaliert werden. Ich verwende (historisch bedingt) 16px PNG-Grafiken (mit Alpha-Channel), die in einer TPngImageList gebündelt sind und Menüs, Schaltflächen, etc. zugewiesen werden.

http://www.delphipraxis.net/attachme...1&d=1461677064

Alle Grafiken neu designen kommt aktuell aufgrund der größeren Menge leider nicht in Frage.
Ich habe keine Möglichkeit gefunden, die Menüs zu überreden, die Icons zu strecken. Aber selbst wenn das gehen würde, wäre die Qualität der Vergrößerung vermutlich eher bescheiden.

Daher die Frage:
Wie lässt sich eine TPngImageList mit samt aller enthaltenen Grafiken am besten hochskalieren?

Ich versuche es aktuell so:

Delphi-Quellcode:

			  pilTemp := TPngImageList.Create(nil);

  try

    pilTemp.AddImages(pil16);

    pil16.SetSize(24, 24); //dadurch gehen alle Grafiken verloren; 24 ist nur ein fixes Beispiel

    for i := 0 to pilTemp.Count-1 do

    begin

      png := pilTemp.PngImages[i].PngImage;

      SmoothResize(png, 24, 24);

      pil16.AddPng(png);

    end;

  finally

    pilTemp.Free;

  end;

Delphi-Quellcode:

SmoothResize

ist dabei eine Funktion von hier:

http://cc.embarcadero.com/Item/25631

Delphi-Quellcode:

			 procedure SmoothResize(apng: TPNGObject; newWidth, newHeight: Integer);

var

  xscale, yscale         : Single;

  sfrom_y, sfrom_x       : Single;

  ifrom_y, ifrom_x       : Integer;

  to_y, to_x             : Integer;

  weight_x, weight_y     : array[0..1] of Single;

  weight                 : Single;

  new_red, new_green     : Integer;

  new_blue, new_alpha    : Integer;

  new_colortype          : Integer;

  total_red, total_green : Single;

  total_blue, total_alpha: Single;

  isAlpha                : Boolean;

  ix, iy                 : Integer;

  bTmp : TPNGObject;

  sli, slo : pRGBLine;

  ali, alo: pbytearray;

begin

  if not (apng.Header.ColorType in [COLOR_RGBALPHA, COLOR_RGB]) then

    raise Exception.Create('Only COLOR_RGBALPHA and COLOR_RGB formats are supported');

  isAlpha := apng.Header.ColorType in [COLOR_RGBALPHA];

  if isAlpha then

    new_colortype := COLOR_RGBALPHA

  else

    new_colortype := COLOR_RGB;

  bTmp := TPNGObject.CreateBlank(new_colortype, 8, newWidth, newHeight);

  xscale := bTmp.Width / (apng.Width-1);

  yscale := bTmp.Height / (apng.Height-1);

  for to_y := 0 to bTmp.Height-1 do

  begin

    sfrom_y := to_y / yscale;

    ifrom_y := Trunc(sfrom_y);

    weight_y[1] := sfrom_y - ifrom_y;

    weight_y[0] := 1 - weight_y[1];

    for to_x := 0 to bTmp.Width-1 do

    begin

      sfrom_x := to_x / xscale;

      ifrom_x := Trunc(sfrom_x);

      weight_x[1] := sfrom_x - ifrom_x;

      weight_x[0] := 1 - weight_x[1];

      total_red   := 0.0;

      total_green := 0.0;

      total_blue  := 0.0;

      total_alpha  := 0.0;

      for ix := 0 to 1 do

      begin

        for iy := 0 to 1 do

        begin

          sli := apng.Scanline[ifrom_y + iy];

          if isAlpha then

            ali := apng.AlphaScanline[ifrom_y + iy];

          new_red := sli[ifrom_x + ix].rgbtRed;

          new_green := sli[ifrom_x + ix].rgbtGreen;

          new_blue := sli[ifrom_x + ix].rgbtBlue;

          if isAlpha then

            new_alpha := ali[ifrom_x + ix];

          weight := weight_x[ix] * weight_y[iy];

          total_red   := total_red   + new_red   * weight;

          total_green := total_green + new_green * weight;

          total_blue  := total_blue  + new_blue  * weight;

          if isAlpha then

            total_alpha  := total_alpha  + new_alpha  * weight;

        end;

      end;

      slo := bTmp.ScanLine[to_y];

      if isAlpha then

        alo := bTmp.AlphaScanLine[to_y];

      slo[to_x].rgbtRed := Round(total_red);

      slo[to_x].rgbtGreen := Round(total_green);

      slo[to_x].rgbtBlue := Round(total_blue);

      if isAlpha then

        alo[to_x] := Round(total_alpha);

    end;

  end;

  apng.Assign(bTmp);

  bTmp.Free;

end;

Das funktioniert auch bis zu einem gewissen Grad ganz gut. Allerdings hat die Funktion Probleme damit, wenn bei der Ursprungsgrafik Pixel direkt am Rand liegen. Diese werden nach der Vergrößerung leider nicht so weich wie die anderen Bildteile, sondern sehen eher abgeschnitten aus.
Außerdem bin ich mir unsicher, ob das überhaupt der richtige Weg zum Weiterverfolgen ist.

Ich bin doch sicherlich nicht der einzige, der seine Anwendungen für hochauflösende Bildschirme anpassen möchte. Wie habt Ihr das denn gemacht? Wie lässt sich meine Methode verbessern?