So ändern Sie die Größe eines Bildes C #

288

Wie Size, Widthund Heightsind Get()Eigenschaften System.Drawing.Image;
Wie kann ich die Größe eines Image-Objekts zur Laufzeit in C # ändern?

Im Moment erstelle ich eine neue ImageVerwendung mit:

// objImage is the original Image
Bitmap objBitmap = new Bitmap(objImage, new Size(227, 171));
Inutan
quelle
2
Nicht der richtige Weg ... verwendet eine Interpolation von geringer Qualität und kann dazu führen, dass der ursprüngliche Stream für die Dauer des neuen Bitmap-Bilds gesperrt bleibt ... Lesen Sie die Fallstricke zur Größenänderung von Bildern, bevor Sie Ihre eigene Lösung zur Größenänderung von Bildern ausführen.
Lilith River
2
Entsorgen Sie das! Using () {} funktioniert!
Scott Coates
8
Wenn diese Antworten hilfreich sind, sollten Sie die akzeptierte Antwort markieren.
Joel
3
Es ist keine zusätzliche Bibliothek erforderlich. Der unten von Mark veröffentlichte Code funktioniert einwandfrei.
Elmue
9
Wer ist Mark? Ich habe seine Antwort nicht gefunden, aber es gibt 3 Kommentare, die darauf verweisen.
Sinatr

Antworten:

490

Dadurch wird eine qualitativ hochwertige Größenänderung durchgeführt:

/// <summary>
/// Resize the image to the specified width and height.
/// </summary>
/// <param name="image">The image to resize.</param>
/// <param name="width">The width to resize to.</param>
/// <param name="height">The height to resize to.</param>
/// <returns>The resized image.</returns>
public static Bitmap ResizeImage(Image image, int width, int height)
{
    var destRect = new Rectangle(0, 0, width, height);
    var destImage = new Bitmap(width, height);

    destImage.SetResolution(image.HorizontalResolution, image.VerticalResolution);

    using (var graphics = Graphics.FromImage(destImage))
    {
        graphics.CompositingMode = CompositingMode.SourceCopy;
        graphics.CompositingQuality = CompositingQuality.HighQuality;
        graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
        graphics.SmoothingMode = SmoothingMode.HighQuality;
        graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;

        using (var wrapMode = new ImageAttributes())
        {
            wrapMode.SetWrapMode(WrapMode.TileFlipXY);
            graphics.DrawImage(image, destRect, 0, 0, image.Width,image.Height, GraphicsUnit.Pixel, wrapMode);
        }
    }

    return destImage;
}
  • wrapMode.SetWrapMode(WrapMode.TileFlipXY) Verhindert Geisterbilder an den Bildrändern. Durch naive Größenänderung werden transparente Pixel über die Bildgrenzen hinaus abgetastet. Durch Spiegeln des Bildes erhalten wir jedoch ein besseres Sample (diese Einstellung ist sehr auffällig).
  • destImage.SetResolution behält die DPI unabhängig von der physischen Größe bei - kann die Qualität beim Reduzieren der Bildabmessungen oder beim Drucken erhöhen
  • Das Zusammensetzen steuert, wie Pixel mit dem Hintergrund gemischt werden - möglicherweise nicht erforderlich, da wir nur eine Sache zeichnen.
    • graphics.CompositingModeLegt fest, ob Pixel aus einem Quellbild überschrieben oder mit Hintergrundpixeln kombiniert werden. SourceCopyGibt an, dass beim Rendern einer Farbe die Hintergrundfarbe überschrieben wird.
    • graphics.CompositingQuality bestimmt die Renderqualitätsstufe von überlagerten Bildern.
  • graphics.InterpolationMode legt fest, wie Zwischenwerte zwischen zwei Endpunkten berechnet werden
  • graphics.SmoothingMode Gibt an, ob Linien, Kurven und Kanten gefüllter Bereiche geglättet werden (auch als Antialiasing bezeichnet) - funktioniert wahrscheinlich nur bei Vektoren
  • graphics.PixelOffsetMode Beeinflusst die Renderqualität beim Zeichnen des neuen Bildes

Das Beibehalten des Seitenverhältnisses bleibt dem Leser als Übung (eigentlich glaube ich nicht, dass es die Aufgabe dieser Funktion ist, dies für Sie zu tun).

Auch dies ist ein guter Artikel einige der Gefahren mit Skalierung von Bildern beschreibt. Die obige Funktion deckt die meisten von ihnen ab, aber Sie müssen sich immer noch um das Speichern kümmern .

mpen
quelle
4
Der Code funktionierte beim Ändern der Bildgröße einwandfrei, erhöhte jedoch die Größe von 66 KB auf 132 KB. Hacke kann ich es reduzieren
Chamara
3
@chamara Das liegt wahrscheinlich an der Qualität, die Sie gewählt haben. Siehe msdn.microsoft.com/en-us/library/bb882583(v=vs.110).aspx Versuchen Sie Qualität = 90
mpen
3
@kstubs Sie sind sicher. BitmapIst im Wesentlichen nur der Name der Klasse, können Sie sie als beliebigen Dateityp speichern.
Mpen
5
@dotNetBlackBelt Sie müssen wahrscheinlich einen Verweis auf System.Drawinghinzufügen und hinzufügenusing System.Drawing.Imaging;
mpen
2
Dadurch wird das ursprüngliche Seitenverhältnis nicht beibehalten, oder?
Kasper Skov
148

Sie sind sich nicht sicher, was daran so schwierig ist. Machen Sie das, was Sie getan haben. Verwenden Sie den überladenen Bitmap-Konstruktor, um ein Bild in neuer Größe zu erstellen. Das einzige, was Ihnen fehlte, war eine Rückbesetzung in den Bilddatentyp:

    public static Image resizeImage(Image imgToResize, Size size)
    {
       return (Image)(new Bitmap(imgToResize, size));
    }

    yourImage = resizeImage(yourImage, new Size(50,50));
Matt
quelle
2
Sollten Sie nicht entsorgen, yourImagebevor Sie es dem neuen Bild zuweisen?
Nick Shaw
3
Sie können es manuell entsorgen oder den Garbage Collector seine Arbeit machen lassen. Ganz gleich.
Elmue
23
Dieser Code gibt keine Kontrolle über die Qualität der Größenänderung, was sehr wichtig ist. Schauen Sie sich die Antwort von Mark an.
Elmue
42

In dieser Frage haben Sie einige Antworten, einschließlich meiner:

public Image resizeImage(int newWidth, int newHeight, string stPhotoPath)
 {
     Image imgPhoto = Image.FromFile(stPhotoPath); 

     int sourceWidth = imgPhoto.Width;
     int sourceHeight = imgPhoto.Height;

     //Consider vertical pics
    if (sourceWidth < sourceHeight)
    {
        int buff = newWidth;

        newWidth = newHeight;
        newHeight = buff;
    }

    int sourceX = 0, sourceY = 0, destX = 0, destY = 0;
    float nPercent = 0, nPercentW = 0, nPercentH = 0;

    nPercentW = ((float)newWidth / (float)sourceWidth);
    nPercentH = ((float)newHeight / (float)sourceHeight);
    if (nPercentH < nPercentW)
    {
        nPercent = nPercentH;
        destX = System.Convert.ToInt16((newWidth -
                  (sourceWidth * nPercent)) / 2);
    }
    else
    {
        nPercent = nPercentW;
        destY = System.Convert.ToInt16((newHeight -
                  (sourceHeight * nPercent)) / 2);
    }

    int destWidth = (int)(sourceWidth * nPercent);
    int destHeight = (int)(sourceHeight * nPercent);


    Bitmap bmPhoto = new Bitmap(newWidth, newHeight,
                  PixelFormat.Format24bppRgb);

    bmPhoto.SetResolution(imgPhoto.HorizontalResolution,
                 imgPhoto.VerticalResolution);

    Graphics grPhoto = Graphics.FromImage(bmPhoto);
    grPhoto.Clear(Color.Black);
    grPhoto.InterpolationMode =
        System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

    grPhoto.DrawImage(imgPhoto,
        new Rectangle(destX, destY, destWidth, destHeight),
        new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight),
        GraphicsUnit.Pixel);

    grPhoto.Dispose();
    imgPhoto.Dispose();
    return bmPhoto;
}
Vinzz
quelle
5
Sie haben imgPhoto.Dispose () vergessen; Die Datei wird weiterhin verwendet
shrutyzet
1
Dies ist sehr hilfreich und ich verwende dies in meiner App. Es ist jedoch wichtig zu beachten, dass dieser Algorithmus nicht mit transparenten Bildern funktioniert. Alle transparenten Pixel werden schwarz. Es ist wahrscheinlich leicht zu beheben, aber es ist nur ein Hinweis für Benutzer. :)
Meme
1
Wollen Sie das Bild nicht speichern? imgPhoto.Save ()?
Schleudertrauma
@meme Können Sie einen Link geben, wie Sie diesen schwarzen Hintergrund für ein transparentes Dokument reparieren können?
Syed Mohamed
25

Warum nicht die System.Drawing.Image.GetThumbnailImageMethode anwenden?

public Image GetThumbnailImage(
    int thumbWidth, 
    int thumbHeight, 
    Image.GetThumbnailImageAbort callback, 
    IntPtr callbackData)

Beispiel:

Image originalImage = System.Drawing.Image.FromStream(inputStream, true, true);
Image resizedImage = originalImage.GetThumbnailImage(newWidth, (newWidth * originalImage.Height) / originalWidth, null, IntPtr.Zero);
resizedImage.Save(imagePath, ImageFormat.Png);

Quelle: http://msdn.microsoft.com/en-us/library/system.drawing.image.getthumbnailimage.aspx

Lino Silva
quelle
6
Dies ist nicht die richtige Methode zum Ändern der Bildgröße. Dadurch wird ein Miniaturbild aus dem JPG gezogen, falls vorhanden. Wenn es nicht vorhanden ist, haben Sie keine Kontrolle über die Qualität oder das neue Bild. Auch dieser Code hat Speicherlecks.
Robert Smith
1
@ Bobrot Warum führt dies zu Speicherlecks?
Benutzer
2
Alles in der GDI-Bibliothek wird noch nicht verwaltet. Ohne eine using-Anweisung zu verwenden oder die Objekte anschließend zu entsorgen, kann es lange dauern, bis das System diese Objekte mit Müll sammelt und den Speicher wieder verfügbar macht.
Robert Smith
9
Es ist wie Sie sagen: Es kann lange dauern. Dies ist jedoch KEIN Speicherverlust. Es wäre ein Speicherverlust, wenn der Speicher NIEMALS freigegeben würde. Dies ist jedoch das NORMALE Verhalten des Garbage Collectors, das Speicher freigibt, wenn die CPU inaktiv ist. Die Anweisung using () verhindert keine Speicherverluste. Der Speicher wird nur sofort freigegeben, während der Garbage Collector den Speicher freigibt, wenn er Zeit dazu hat. Das ist der einzige Unterschied in diesem speziellen Fall.
Elmue
Siehe Fallstricke bei der Größenänderung von Bildern : nathanaeljones.com/blog/2009/20-image-resizing-pitfalls "GetThumbnailImage () verwenden. GetThumbnailImage () scheint die naheliegende Wahl zu sein, und viele Artikel empfehlen die Verwendung. Leider greift es immer nach dem eingebetteten JPEG Miniaturbild, falls vorhanden. Einige Fotos haben diese, andere nicht - dies hängt normalerweise von Ihrer Kamera ab. Sie werden sich fragen, warum GetThumbnailImage bei einigen Fotos gut funktioniert, bei anderen jedoch schrecklich unscharf. GetThumbnailImage () ist für größere Fotos nicht zuverlässig als 10px mal 10px aus diesem Grund. "
Nick Painter
12

Sie können net-vips ausprobieren , die C # -Bindung für libvips . Es handelt sich um eine faule, Streaming- und bedarfsgesteuerte Bildverarbeitungsbibliothek, mit der solche Vorgänge ausgeführt werden können, ohne dass das gesamte Bild geladen werden muss.

Zum Beispiel wird ein praktischer Miniaturbildbildschirm mitgeliefert:

Image image = Image.Thumbnail("image.jpg", 300, 300);
image.WriteToFile("my-thumbnail.jpg");

Es unterstützt auch Smart Crop, eine Möglichkeit, den wichtigsten Teil des Bildes intelligent zu bestimmen und es beim Zuschneiden des Bildes scharf zu halten. Beispielsweise:

Image image = Image.Thumbnail("owl.jpg", 128, crop: "attention");
image.WriteToFile("tn_owl.jpg");

Wo owl.jpgist eine außermittige Komposition:

Eule

Gibt dieses Ergebnis:

Eule kluge Ernte

Zuerst wird das Bild verkleinert, um die vertikale Achse auf 128 Pixel zu bringen, und dann mithilfe der attentionStrategie auf 128 Pixel verkleinert . Dieser durchsucht das Bild nach Merkmalen, die ein menschliches Auge auf sich ziehen könnten. Weitere Smartcrop()Informationen finden Sie hier.

kleisauke
quelle
Ihre Bindung für libvips scheint großartig. Ich werde auf jeden Fall einen Blick auf Ihre Bibliothek werfen. Vielen Dank, dass Sie dies C # Developer zur Verfügung stellen!
FrenchTastic
Das ist großartig! Ich hatte keine Ahnung, dass eine Bildverarbeitungsbibliothek so gut aussehen könnte.
Dalvir
nett! besser als ImageMagick schwer
Moshe L
10

Dieser Wille -

  • Ändern Sie die Größe von Breite UND Höhe, ohne dass eine Schleife erforderlich ist
  • Überschreitet nicht die ursprünglichen Abmessungen der Bilder

////////////////

private void ResizeImage(Image img, double maxWidth, double maxHeight)
{
    double resizeWidth = img.Source.Width;
    double resizeHeight = img.Source.Height;

    double aspect = resizeWidth / resizeHeight;

    if (resizeWidth > maxWidth)
    {
        resizeWidth = maxWidth;
        resizeHeight = resizeWidth / aspect;
    }
    if (resizeHeight > maxHeight)
    {
        aspect = resizeWidth / resizeHeight;
        resizeHeight = maxHeight;
        resizeWidth = resizeHeight * aspect;
    }

    img.Width = resizeWidth;
    img.Height = resizeHeight;
}
Dominic
quelle
11
OP hat nach System.Drawing.Image gefragt, wo Ihr Code nicht funktioniert, da die Eigenschaften 'Breite' und 'Höhe' nicht einstellbar sind. Es funktioniert jedoch für System.Windows.Controls.Image.
mmmdreg
10
public static Image resizeImage(Image image, int new_height, int new_width)
{
    Bitmap new_image = new Bitmap(new_width, new_height);
    Graphics g = Graphics.FromImage((Image)new_image );
    g.InterpolationMode = InterpolationMode.High;
    g.DrawImage(image, 0, 0, new_width, new_height);
    return new_image;
}
NeoSvet
quelle
Sie haben vergessen, Grafiken zu entsorgen. Scheint das gleiche Prinzip wie die neue Bitmap (Bild, Breite, Höhe) mit besserem Interpolationsmodus. Ich bin gespannt, was Standard ist . Ist es noch schlimmer als Low?
Sinatr
9

Dieser Code ist der gleiche wie in einer der obigen Antworten. Er konvertiert jedoch transparente Pixel in Weiß anstelle von Schwarz ... Danke :)

    public Image resizeImage(int newWidth, int newHeight, string stPhotoPath)
    {
        Image imgPhoto = Image.FromFile(stPhotoPath);

        int sourceWidth = imgPhoto.Width;
        int sourceHeight = imgPhoto.Height;

        //Consider vertical pics
        if (sourceWidth < sourceHeight)
        {
            int buff = newWidth;

            newWidth = newHeight;
            newHeight = buff;
        }

        int sourceX = 0, sourceY = 0, destX = 0, destY = 0;
        float nPercent = 0, nPercentW = 0, nPercentH = 0;

        nPercentW = ((float)newWidth / (float)sourceWidth);
        nPercentH = ((float)newHeight / (float)sourceHeight);
        if (nPercentH < nPercentW)
        {
            nPercent = nPercentH;
            destX = System.Convert.ToInt16((newWidth -
                      (sourceWidth * nPercent)) / 2);
        }
        else
        {
            nPercent = nPercentW;
            destY = System.Convert.ToInt16((newHeight -
                      (sourceHeight * nPercent)) / 2);
        }

        int destWidth = (int)(sourceWidth * nPercent);
        int destHeight = (int)(sourceHeight * nPercent);


        Bitmap bmPhoto = new Bitmap(newWidth, newHeight,
                      PixelFormat.Format24bppRgb);

        bmPhoto.SetResolution(imgPhoto.HorizontalResolution,
                     imgPhoto.VerticalResolution);

        Graphics grPhoto = Graphics.FromImage(bmPhoto);
        grPhoto.Clear(Color.White);
        grPhoto.InterpolationMode =
            System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

        grPhoto.DrawImage(imgPhoto,
            new Rectangle(destX, destY, destWidth, destHeight),
            new Rectangle(sourceX, sourceY, sourceWidth, sourceHeight),
            GraphicsUnit.Pixel);

        grPhoto.Dispose();
        imgPhoto.Dispose();

        return bmPhoto;
    }
Rajesh
quelle
7

In der von mir erstellten Anwendung musste eine Funktion mit mehreren Optionen erstellt werden. Es ist ziemlich groß, ändert jedoch die Bildgröße, kann das Seitenverhältnis beibehalten und die Kanten abschneiden, um nur die Bildmitte zurückzugeben:

/// <summary>
    /// Resize image with a directory as source
    /// </summary>
    /// <param name="OriginalFileLocation">Image location</param>
    /// <param name="heigth">new height</param>
    /// <param name="width">new width</param>
    /// <param name="keepAspectRatio">keep the aspect ratio</param>
    /// <param name="getCenter">return the center bit of the image</param>
    /// <returns>image with new dimentions</returns>
    public Image resizeImageFromFile(String OriginalFileLocation, int heigth, int width, Boolean keepAspectRatio, Boolean getCenter)
    {
        int newheigth = heigth;
        System.Drawing.Image FullsizeImage = System.Drawing.Image.FromFile(OriginalFileLocation);

        // Prevent using images internal thumbnail
        FullsizeImage.RotateFlip(System.Drawing.RotateFlipType.Rotate180FlipNone);
        FullsizeImage.RotateFlip(System.Drawing.RotateFlipType.Rotate180FlipNone);

        if (keepAspectRatio || getCenter)
        {
            int bmpY = 0;
            double resize = (double)FullsizeImage.Width / (double)width;//get the resize vector
            if (getCenter)
            {
                bmpY = (int)((FullsizeImage.Height - (heigth * resize)) / 2);// gives the Y value of the part that will be cut off, to show only the part in the center
                Rectangle section = new Rectangle(new Point(0, bmpY), new Size(FullsizeImage.Width, (int)(heigth * resize)));// create the section to cut of the original image
                //System.Console.WriteLine("the section that will be cut off: " + section.Size.ToString() + " the Y value is minimized by: " + bmpY);
                Bitmap orImg = new Bitmap((Bitmap)FullsizeImage);//for the correct effect convert image to bitmap.
                FullsizeImage.Dispose();//clear the original image
                using (Bitmap tempImg = new Bitmap(section.Width, section.Height))
                {
                    Graphics cutImg = Graphics.FromImage(tempImg);//              set the file to save the new image to.
                    cutImg.DrawImage(orImg, 0, 0, section, GraphicsUnit.Pixel);// cut the image and save it to tempImg
                    FullsizeImage = tempImg;//save the tempImg as FullsizeImage for resizing later
                    orImg.Dispose();
                    cutImg.Dispose();
                    return FullsizeImage.GetThumbnailImage(width, heigth, null, IntPtr.Zero);
                }
            }
            else newheigth = (int)(FullsizeImage.Height / resize);//  set the new heigth of the current image
        }//return the image resized to the given heigth and width
        return FullsizeImage.GetThumbnailImage(width, newheigth, null, IntPtr.Zero);
    }

Um den Zugriff auf die Funktion zu vereinfachen, können einige überladene Funktionen hinzugefügt werden:

/// <summary>
    /// Resize image with a directory as source
    /// </summary>
    /// <param name="OriginalFileLocation">Image location</param>
    /// <param name="heigth">new height</param>
    /// <param name="width">new width</param>
    /// <returns>image with new dimentions</returns>
    public Image resizeImageFromFile(String OriginalFileLocation, int heigth, int width)
    {
        return resizeImageFromFile(OriginalFileLocation, heigth, width, false, false);
    }

    /// <summary>
    /// Resize image with a directory as source
    /// </summary>
    /// <param name="OriginalFileLocation">Image location</param>
    /// <param name="heigth">new height</param>
    /// <param name="width">new width</param>
    /// <param name="keepAspectRatio">keep the aspect ratio</param>
    /// <returns>image with new dimentions</returns>
    public Image resizeImageFromFile(String OriginalFileLocation, int heigth, int width, Boolean keepAspectRatio)
    {
        return resizeImageFromFile(OriginalFileLocation, heigth, width, keepAspectRatio, false);
    }

Jetzt können die letzten beiden Booleschen Werte optional festgelegt werden. Rufen Sie die Funktion folgendermaßen auf:

System.Drawing.Image ResizedImage = resizeImageFromFile(imageLocation, 800, 400, true, true);
Quispie
quelle
6
public string CreateThumbnail(int maxWidth, int maxHeight, string path)
{

    var image = System.Drawing.Image.FromFile(path);
    var ratioX = (double)maxWidth / image.Width;
    var ratioY = (double)maxHeight / image.Height;
    var ratio = Math.Min(ratioX, ratioY);
    var newWidth = (int)(image.Width * ratio);
    var newHeight = (int)(image.Height * ratio);
    var newImage = new Bitmap(newWidth, newHeight);
    Graphics thumbGraph = Graphics.FromImage(newImage);

    thumbGraph.CompositingQuality = CompositingQuality.HighQuality;
    thumbGraph.SmoothingMode = SmoothingMode.HighQuality;
    //thumbGraph.InterpolationMode = InterpolationMode.HighQualityBicubic;

    thumbGraph.DrawImage(image, 0, 0, newWidth, newHeight);
    image.Dispose();

    string fileRelativePath = "newsizeimages/" + maxWidth + Path.GetFileName(path);
    newImage.Save(Server.MapPath(fileRelativePath), newImage.RawFormat);
    return fileRelativePath;
}

Klicken Sie hier http://bhupendrasinghsaini.blogspot.in/2014/07/resize-image-in-c.html

Bhupendra Singh
quelle
6

Dies ist der Code, den ich für eine bestimmte Anforderung ausgearbeitet habe, dh: Das Ziel befindet sich immer im Querformat. Es sollte Ihnen einen guten Start geben.

public Image ResizeImage(Image source, RectangleF destinationBounds)
{
    RectangleF sourceBounds = new RectangleF(0.0f,0.0f,(float)source.Width, (float)source.Height);
    RectangleF scaleBounds = new RectangleF();

    Image destinationImage = new Bitmap((int)destinationBounds.Width, (int)destinationBounds.Height);
    Graphics graph = Graphics.FromImage(destinationImage);
    graph.InterpolationMode =
        System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

    // Fill with background color
    graph.FillRectangle(new SolidBrush(System.Drawing.Color.White), destinationBounds);

    float resizeRatio, sourceRatio;
    float scaleWidth, scaleHeight;

    sourceRatio = (float)source.Width / (float)source.Height;

    if (sourceRatio >= 1.0f)
    {
        //landscape
        resizeRatio = destinationBounds.Width / sourceBounds.Width;
        scaleWidth = destinationBounds.Width;
        scaleHeight = sourceBounds.Height * resizeRatio;
        float trimValue = destinationBounds.Height - scaleHeight;
        graph.DrawImage(source, 0, (trimValue / 2), destinationBounds.Width, scaleHeight);
    }
    else
    {
        //portrait
        resizeRatio = destinationBounds.Height/sourceBounds.Height;
        scaleWidth = sourceBounds.Width * resizeRatio;
        scaleHeight = destinationBounds.Height;
        float trimValue = destinationBounds.Width - scaleWidth;
        graph.DrawImage(source, (trimValue / 2), 0, scaleWidth, destinationBounds.Height);
    }

    return destinationImage;

}
Leslie Marshall
quelle
Genial!!! Ich hatte Probleme mit einem Porträtbild und nachdem ich viele im Internet gesuchte Lösungen ausprobiert hatte, war dies das EINZIGE, das PERFEKT war! ICH DANKE DIR SEHR!
Fábio
3

Wenn Sie mit einem arbeiten BitmapSource:

var resizedBitmap = new TransformedBitmap(
    bitmapSource,
    new ScaleTransform(scaleX, scaleY));

Wenn Sie eine genauere Kontrolle über die Qualität wünschen, führen Sie zuerst Folgendes aus:

RenderOptions.SetBitmapScalingMode(
    bitmapSource,
    BitmapScalingMode.HighQuality);

(Die Standardeinstellung BitmapScalingMode.Linearentspricht BitmapScalingMode.LowQuality.)

Mateen Ulhaq
quelle
3

Ich benutze ImageProcessorCore, hauptsächlich weil es .Net Core funktioniert.

Und es gibt mehr Optionen wie das Konvertieren von Typen, das Zuschneiden von Bildern und vieles mehr

http://imageprocessor.org/imageprocessor/

Topolm
quelle
1
Ich habe nachgesehen und dies unterstützt .NET Core nicht. Es ist gegen den vollen Rahmen gebaut.
Chrisdrobison
1

Ändern Sie die Größe und speichern Sie ein Bild so, dass es wie eine Leinwand unter Breite und Höhe passt und das Bild proportional bleibt

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;

namespace Infra.Files
{
    public static class GenerateThumb
    {
        /// <summary>
        /// Resize and save an image to fit under width and height like a canvas keeping things proportional
        /// </summary>
        /// <param name="originalImagePath"></param>
        /// <param name="thumbImagePath"></param>
        /// <param name="newWidth"></param>
        /// <param name="newHeight"></param>
        public static void GenerateThumbImage(string originalImagePath, string thumbImagePath, int newWidth, int newHeight)
        {
            Bitmap srcBmp = new Bitmap(originalImagePath);
            float ratio = 1;
            float minSize = Math.Min(newHeight, newHeight);

            if (srcBmp.Width > srcBmp.Height)
            {
                ratio = minSize / (float)srcBmp.Width;
            }
            else
            {
                ratio = minSize / (float)srcBmp.Height;
            }

            SizeF newSize = new SizeF(srcBmp.Width * ratio, srcBmp.Height * ratio);
            Bitmap target = new Bitmap((int)newSize.Width, (int)newSize.Height);

            using (Graphics graphics = Graphics.FromImage(target))
            {
                graphics.CompositingQuality = CompositingQuality.HighSpeed;
                graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
                graphics.CompositingMode = CompositingMode.SourceCopy;
                graphics.DrawImage(srcBmp, 0, 0, newSize.Width, newSize.Height);

                using (MemoryStream memoryStream = new MemoryStream())
                {
                    target.Save(thumbImagePath);
                }
            }
        }
    }
}
Andrew Paes
quelle
1

Verwenden Sie die folgende Funktion mit dem folgenden Beispiel, um die Bildgröße zu ändern:

//Example : 
System.Net.Mime.MediaTypeNames.Image newImage = System.Net.Mime.MediaTypeNames.Image.FromFile("SampImag.jpg");
System.Net.Mime.MediaTypeNames.Image temImag = FormatImage(newImage, 100, 100);

//image size modification unction   
public static System.Net.Mime.MediaTypeNames.Image FormatImage(System.Net.Mime.MediaTypeNames.Image img, int outputWidth, int outputHeight)
{

    Bitmap outputImage = null;
    Graphics graphics = null;
    try
    {
         outputImage = new Bitmap(outputWidth, outputHeight, System.Drawing.Imaging.PixelFormat.Format16bppRgb555);
         graphics = Graphics.FromImage(outputImage);
         graphics.DrawImage(img, new Rectangle(0, 0, outputWidth, outputHeight),
         new Rectangle(0, 0, img.Width, img.Height), GraphicsUnit.Pixel);

         return outputImage;
     }
     catch (Exception ex)
     {
           return img;
     }
}
Prasad KM
quelle
2
Bitte erläutern Sie in Ihrer obigen Antwort, wie Sie diesen Code verwenden, was der Code tut und wie er das Problem in der ursprünglichen Frage löst.
Tim Visée
Ich habe auch Anwendungsfall hinzugefügt. Verwenden Sie die obige Funktion anhand des folgenden Beispiels. Image newImage = Image.FromFile ("SampImag.jpg"); Image temImag = FormatImage (newImage, 100, 100);
Prasad KM
0

Hinweis: Dies funktioniert nicht mit ASP.Net Core, da WebImage von System.Web abhängt. In früheren Versionen von ASP.Net habe ich dieses Snippet jedoch häufig verwendet und war nützlich.

String ThumbfullPath = Path.GetFileNameWithoutExtension(file.FileName) + "80x80.jpg";
var ThumbfullPath2 = Path.Combine(ThumbfullPath, fileThumb);
using (MemoryStream stream = new MemoryStream(System.IO.File.ReadAllBytes(fullPath)))
{
      var thumbnail = new WebImage(stream).Resize(80, 80);
      thumbnail.Save(ThumbfullPath2, "jpg");
}
JoshYates1980
quelle