Quadratische Thumbnails erstellen

[capo]

Hallo,
hier im Forum sind unzählige Beispiele wie Thumbnails erstellt werden z.B.
http://www.delphipraxis.net/105189-t...rkleinern.html

Oder dieses:

Delphi-Quellcode:

procedure SaveImage(inBmp: TBitmap32; filename: string);
var jpeg: TJPEGImage;
  bmp: TBitmap;
begin
  jpeg := TJPEGImage.Create;
  bmp := TBitmap.Create;
  try
    bmp.Assign(inBmp);
    jpeg.CompressionQuality := 100;
    jpeg.Assign(bmp);

    jpeg.SaveToFile(filename);
  finally
    jpeg.Free;
    bmp.Free;
  end;
end;



procedure resizePicture(infile: string; outfile: string; width, height: integer;
  aspectratio: boolean);
var srcpic, destpic: TBitmap32;
  destrect, srcrect: TRect;
begin
  srcpic := TBitmap32.Create;
  destpic := TBitmap32.Create;
  try
    srcpic.LoadFromFile(infile);
    if aspectratio = true then begin
      if srcpic.Height > srcpic.Width then begin
        width := height * srcpic.width div srcpic.height;
      end else begin
        height := width * srcpic.Height div srcpic.Width;
      end;
    end;
    try
      destpic.width := width;
      destpic.height := height;
      destrect := Rect(0, 0, destpic.width, destpic.height);
      srcrect := Rect(0, 0, srcpic.width, srcpic.height);
      srcpic.SetSize(67, 67);
      srcpic.Stretch(NewWidth, NewHeight, sfLanczos3, 0, BMP);
          // srcpic.StretchFilter:=sfLanczos; FUNKTIONIERT NICHT, WARUM?
      destpic.Draw(destrect, srcrect, srcpic);
    finally
      srcpic.free;
    end;
    SaveImage(destpic, outfile);
  finally
    destpic.free;
  end;
end;

Ich habe das Problem das ich quadratische Thumbnails brauche.
Die Ursprungsbilder sind hoch- und querformatig.
Wenn ich auf eine bestimmte Breite oder Höhe reduziere und den Rest stretche sieht es unter Umständen richtig verzehrt aus.

Hat jemand eine Idee wie mir das gelingen könnte?

Gruß
capo

[Matze]

Ermittel doch einfach die kürzere der beiden Seiten (simpler Vergleich) und nimm den als Kante des Quadrats und erstellst damit z.B.ein neues quadratisches Bild.
Die Differenz zwischen langer und kurzer Seite geteilt durch 2 ist das, was du an jeder Seite abschneiden musst.

Einfach entsprechend aufs neue, quadratische Bild kopieren und fertig.

[Bummi]

Delphi-Quellcode:

Procedure DrawBMPToCanvas(bmp:TBitmap;Canvas:TCanvas;Destrect:TRect);
var
    x,y,x1,y1:Double;
    Arect:TRect;
begin
      y:=bmp.Height;
      x:=bmp.Width;
      y1:=y/(Destrect.Right-Destrect.Left);
      x1:=x/(Destrect.Bottom-Destrect.Top);
      if x1<y1 then x1:=y1 ;
      x:=x/x1;
      y:=y/x1;
      Arect.left:=Destrect.Left+((Destrect.Right-Destrect.Left)-round(x)) div 2 ;
      Arect.top:=Destrect.Top+((Destrect.Bottom-Destrect.Top)-round(y)) div 2;
      Arect.right:=Arect.left+round(x);
      Arect.bottom:=Arect.top+round(y);
      Canvas.Fillrect(Destrect);
      Canvas.stretchdraw(Arect,bmp);
end;

oder mit GDIPAPI, GDIPOBJ

Delphi-Quellcode:

Procedure ScaleImage(Const source,dest:String;DestWidth,DestHeight:Integer;Qual:Integer=92;WithOutMargins:Boolean=false;BgColor:TColor=ClWhite);
var
  HDCImage:TImage;
  graphics : TGPGraphics;
  image: TGPImage;
  width, height: Integer;
  faktor:Double;
  destx,desty:Double;
  Ext:String;
begin

  Ext := UpperCase(StringReplace(ExtractFileExt(dest),'.','',[]));
  image:= TGPImage.Create(source);
  width  := image.GetWidth;
  height := image.GetHeight;
  if (DestWidth / width) < (DestHeight/Height) then faktor  := (DestWidth / width) else faktor:= (DestHeight/Height);
  HDCImage:=TImage.Create(nil);
  if WithOutMargins then
    begin
    HDCImage.Width  :=  Trunc(faktor * width);
    HDCImage.Height :=  Trunc(faktor * height);
    destx :=  0;
    desty :=  0;
    end
  else
    begin
    HDCImage.Width:=DestWidth;
    HDCImage.Height:=DestHeight;
    destx :=  (DestWidth - faktor * width) / 2;
    desty :=  (DestHeight - faktor * Height) / 2
    end;
  if BgColor<>clWhite then
    begin
      HDCImage.Canvas.Brush.Color:=BgColor;
      HDCImage.Canvas.Fillrect(Rect(0,0,HDCImage.Width,HDCImage.Height));
    end;
  graphics := TGPGraphics.Create(HDCImage.Canvas.Handle);
  graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);

  graphics.DrawImage(
    image,
    MakeRect(destx,  desty , faktor * width, faktor * height),  // destination rectangle
    0, 0,        // upper-left corner of source rectangle
    width,       // width of source rectangle
    height,      // height of source rectangle
    UnitPixel);
  image.Free;
  HDCImage.invalidate;
  ForceDirectories(ExtractFilePath(dest));
  if ext = 'BMP' then HDCImage.Picture.Bitmap.SaveToFile(dest)
  else SaveBMPasJPG(dest,HDCImage.Picture.Bitmap,qual);
  graphics.Free;
  HDCImage.Free;

end;

[shmia]

Du hast ein grosses Rechteck und möchtest das verkleinert in ein Quadrat einpassen.
Also muss im Quadrat links und rechts bzw. oben und unten gleich viel Weissraum bleiben.

Zufällig habe ich hier eine Funktion in meiner Schublade:

Delphi-Quellcode:

{**************************************************************************
 * NAME:    MaintainAspectRatio
 * DESC:    Bewirkt, dass das Seitenverhältnis (AspectRatio) bei
 *          Vergrösserungen oder Verkleinerungen bebehalten wird
 *          Es wird nur Integerarithmetik verwendet 
 * PARAMS:  rect => das Zielrechteck
 *          w => Breite
 *          h => Höhe
 *************************************************************************}
procedure MaintainAspectRatio(var rect:TRect; w,h:Integer; Center:Boolean);
var
   w2, h2 : Integer;
   tmp, x : Integer;
begin
   w2 := rect.Right-rect.Left;
   h2 := rect.Bottom-rect.Top;
   Assert(w2 >= 0);
   Assert(h2 >= 0);
   Assert(w >= 0);
   Assert(h >= 0);


   tmp := w2 * h - w * h2;

   if tmp > 0 then
   begin
      // Zielbereich ist zu breit
      x := (w * h2) div h;  // neue Breite
      if Center then
      begin
         Inc(rect.Left, (w2-x) div 2);
      end;
      rect.Right := rect.Left + x;
   end
   else if tmp < 0 then
   begin
      // Zielbereich ist zu hoch
      x := (h * w2) div w;   // neue Höhe
      if Center then
      begin
         Inc(rect.Top, (h2-x) div 2);
      end;
      rect.Bottom := rect.Top + x;
   end
   else
      ;

   Assert(rect.Right >= rect.Left);
   Assert(rect.Bottom >= rect.Top);
   { nur zum Testen
   w2 := rect.Right-rect.Left;
   h2 := rect.Bottom-rect.Top;
   tmp := w2 * h - w * h2;

   tmp müsste ungefähr 0 sein.
   }
end;

Die Anwendung sieht so aus:

Delphi-Quellcode:

var
   zielrect : TRect;
begin
   zielrect := Rect(0,0, 63, 63);  // Grösse Thumbnail
   MaintainAspectRatio(zielrect, Bitmap.Width, Bitmap.Height, True);
   // jetzt ist zielrect so geändert, dass man das Bitmap mit StrechDraw
   // ohne Änderung des Seitenverhältnisses verkleinern kann

[DeddyH]

Dann hab ich auch noch einen: http://www.delphipraxis.net/859482-post4.html

[capo]

Danke, ihr seid der Hammer!
Jetzt kann ich weiter machen.
Gruß
Capo

[shmia]

Zitat von DeddyH:

Dann hab ich auch noch einen...

Also mir gefällt das MaintainAspectRatio am Besten:
keine Divisionen, keine Fliesskommazahlen und keine Abhängigkeiten zu Bitmap, Canvas, Image...

[capo]

Zitat von shmia:

Du hast ein grosses Rechteck und möchtest das verkleinert in ein Quadrat einpassen.
Also muss im Quadrat links und rechts bzw. oben und unten gleich viel Weissraum bleiben.

Geht es auch ohne Weissraum?
Es wäre nicht so schlimm wenn ein Teil fehlen würde.

Wie mache ich das hiermit?

Zitat:

// jetzt ist zielrect so geändert, dass man das Bitmap mit StrechDraw
// ohne Änderung des Seitenverhältnisses verkleinern kann

Gruss
capo

[stahli]

Ist nicht genau das, was Du suchst, aber mal der Vollständigkeit halber...
Ich habe ein Formular, mit dem man einen quadratischen Auszug aus einem Bild auswählen kann. Ist aber halt eine händische Lösung.

[capo]

Zitat von stahli:

Ist nicht genau das, was Du suchst, aber mal der Vollständigkeit halber...
Ich habe ein Formular, mit dem man einen quadratischen Auszug aus einem Bild auswählen kann. Ist aber halt eine händische Lösung.

Gute Idee, das macht der Simpleviewer auch, verkleinert und nimmt sich irgendein Quadrat aus dem Foto heraus.
Das würde mir absolut reichen!

Allerding nicht händisch. Es sind relativ viele Bilder zu bearbeiten.
Danke für deine Ergänzung