Come ridimensionare un'immagine C #


288

Come Size, Widthe Heightsono Get()proprietà System.Drawing.Image;
Come posso ridimensionare un oggetto Image in fase di esecuzione in C #?

In questo momento, sto solo creando un nuovo Imageutilizzo:

// objImage is the original Image
Bitmap objBitmap = new Bitmap(objImage, new Size(227, 171));

2
Non nel modo giusto ... usa l'interpolazione di bassa qualità e può far sì che il flusso originale rimanga bloccato per la durata della nuova immagine bitmap ... Leggi l'elenco delle insidie ​​del ridimensionamento dell'immagine prima di fare la tua soluzione di ridimensionamento dell'immagine.
Lilith River,

2
Smaltiscilo! Utilizzando () {} funziona!
Scott Coates,

8
Se queste risposte sono utili, considera di contrassegnare la risposta accettata.
Gioele

3
Non è necessario utilizzare alcuna libreria aggiuntiva. Il codice pubblicato di seguito da Mark funziona perfettamente.
Elmue,

9
Chi è Mark? Non sono riuscito a trovare la sua risposta, ma ci sono 3 commenti che si riferiscono ad essa.
Sinatr,

Risposte:


490

Ciò eseguirà un ridimensionamento di alta qualità:

/// <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) impedisce il ghosting attorno ai bordi dell'immagine - il ridimensionamento ingenuo campionerà i pixel trasparenti oltre i confini dell'immagine, ma rispecchiando l'immagine possiamo ottenere un campione migliore (questa impostazione è molto evidente)
  • destImage.SetResolution mantiene DPI indipendentemente dalle dimensioni fisiche - può aumentare la qualità quando si riducono le dimensioni dell'immagine o durante la stampa
  • La composizione controlla il modo in cui i pixel si fondono con lo sfondo: potrebbe non essere necessario poiché stiamo disegnando solo una cosa.
    • graphics.CompositingModedetermina se i pixel di un'immagine di origine vengono sovrascritti o combinati con i pixel di sfondo. SourceCopyspecifica che quando viene reso un colore, sovrascrive il colore di sfondo.
    • graphics.CompositingQuality determina il livello di qualità di rendering delle immagini a più livelli.
  • graphics.InterpolationMode determina come vengono calcolati i valori intermedi tra due endpoint
  • graphics.SmoothingMode specifica se le linee, le curve e i bordi delle aree riempite usano il livellamento (chiamato anche antialiasing) - probabilmente funziona solo su vettori
  • graphics.PixelOffsetMode influisce sulla qualità di rendering quando si disegna la nuova immagine

Mantenere le proporzioni viene lasciato come esercizio per il lettore (in realtà, non penso proprio che il compito di questa funzione sia quello di farlo per te).

Inoltre, questo è un buon articolo che descrive alcune delle insidie ​​del ridimensionamento delle immagini. La funzione di cui sopra coprirà la maggior parte di essi, ma devi comunque preoccuparti del salvataggio .


4
il codice ha funzionato perfettamente durante il ridimensionamento dell'immagine ma ha aumentato le dimensioni da 66 KB a 132 KB. Zappa posso ridurlo
Chamara,

3
@chamara Probabilmente è dovuto al risparmio di qualità che hai scelto. Vedi msdn.microsoft.com/en-us/library/bb882583(v=vs.110).aspx Prova qualità = 90
mpen

3
@kstubs Sei sicuro. Bitmapè essenzialmente solo il nome della classe, puoi salvarlo come qualunque tipo di file ti piaccia.
Aprire il

5
@dotNetBlackBelt Probabilmente dovrai aggiungere un riferimento System.Drawinge aggiungereusing System.Drawing.Imaging;
mpen

2
Questo non manterrà le proporzioni originali giusto?
Kasper Skov,

148

Non sono sicuro di cosa sia così difficile, fai quello che stavi facendo, usa il costruttore Bitmap sovraccarico per creare un'immagine ridimensionata, l'unica cosa che mancava era un cast del tipo di dati Image:

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

    yourImage = resizeImage(yourImage, new Size(50,50));

2
Non dovresti smaltire yourImageprima di assegnarlo alla nuova immagine?
Nick Shaw,

3
Puoi smaltirlo manualmente o lasciare che il garbage collector faccia il suo lavoro. Non importa.
Elmue,

23
Questo codice non dà alcun controllo sulla qualità del ridimensionamento, il che è molto importante. Dai un'occhiata alla risposta di Mark.
Elmue,

43

in questa domanda , avrai alcune risposte, tra cui la mia:

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;
}

5
Hai dimenticato imgPhoto.Dispose (); il file viene mantenuto in uso
shrutyzet il

1
Questo è molto utile e lo sto usando nella mia app. Tuttavia è importante notare che questo algoritmo non funziona con immagini trasparenti. Trasforma tutti i pixel trasparenti in neri. Probabilmente è facile da risolvere, ma è solo una nota per gli utenti. :)
meme

1
Non pensi di salvare l'immagine? imgPhoto.Save ()?
Colpo di frusta

@meme Puoi dare un link su come riparare quello sfondo nero per un documento trasparente.
Syed Mohamed,

25

Perché non usare il System.Drawing.Image.GetThumbnailImagemetodo?

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

Esempio:

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);

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


6
Questo non è il modo corretto di ridimensionare un'immagine. Questo estrae una miniatura dal jpg se esiste. Se non esiste, non hai alcun controllo sulla qualità o sulla nuova immagine. Inoltre, questo codice così com'è presenta perdite di memoria.
Robert Smith,

1
@Bobrot Perché questo causerà perdite di memoria?
utente

2
Qualsiasi cosa nella libreria GDI è ancora in esecuzione non gestita. Senza utilizzare un'istruzione using o eliminare gli oggetti in seguito, il sistema può impiegare molto tempo a raccogliere i suddetti oggetti e rendere nuovamente disponibile la memoria.
Robert Smith,

9
È come dici tu: potrebbe richiedere molto tempo. Ma questa NON è una perdita di memoria. Sarebbe una perdita di memoria se la memoria non verrà MAI liberata. Ma questo è il comportamento NORMALE del Garbage Collector che libera memoria quando la CPU è inattiva. L'istruzione using () non impedisce perdite di memoria. Libera immediatamente la memoria mentre il Garbage Collector libera la memoria quando ha il tempo di farlo. Questa è l'unica differenza in questo caso specifico.
Elmue,

Vedi le insidie ​​del ridimensionamento delle immagini: nathanaeljones.com/blog/2009/20-image-resizing-pitfalls "Usare GetThumbnailImage (). GetThumbnailImage () sembra la scelta ovvia e molti articoli ne raccomandano l'uso. Sfortunatamente, afferra sempre il jpeg incorporato miniatura se presente. Alcune foto hanno queste, altre no - di solito dipende dalla tua fotocamera. Ti chiederai perché GetThumbnailImage funzioni bene su alcune foto, ma su altre è orribilmente sfocato. GetThumbnailImage () non è affidabile per le foto più grandi di 10 pixel per 10 pixel per questo motivo. "
Nick Painter,

12

Potresti provare net-vips , l'associazione C # per libvips . È una libreria di elaborazione delle immagini pigra, in streaming, basata sulla domanda, quindi può eseguire operazioni come questa senza dover caricare l'intera immagine.

Ad esempio, viene fornito con un pratico thumbnailer di immagini:

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

Supporta anche il ritaglio intelligente, un modo per determinare in modo intelligente la parte più importante dell'immagine e mantenerla a fuoco durante il ritaglio dell'immagine. Per esempio:

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

Dove si owl.jpgtrova una composizione decentrata:

Gufo

Dà questo risultato:

Ritaglio intelligente di gufo

Innanzitutto riduce l'immagine per portare l'asse verticale a 128 pixel, quindi ritaglia fino a 128 pixel attraverso la attentionstrategia. Questo cerca nell'immagine le caratteristiche che potrebbero catturare un occhio umano, vedi Smartcrop()per i dettagli.


La tua associazione per libvips sembra grande. Daremo sicuramente un'occhiata alla tua lib. Grazie per averlo reso disponibile allo sviluppatore C #!
FrenchTastic

Questo è fantastico! Non avevo idea che una libreria di elaborazione delle immagini potesse essere così bella.
Dalvir,

simpatico! meglio di ImageMagick pesante
Moshe L

10

Questo sarà -

  • Ridimensiona la larghezza E l'altezza senza la necessità di un anello
  • Non supera le dimensioni originali delle immagini

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

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;
}

11
OP stava chiedendo informazioni su System.Drawing.Image, in cui il codice non funzionava poiché le proprietà 'Larghezza' e 'Altezza' non sono impostabili. Funzionerà, tuttavia, per 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;
}

Hai dimenticato di smaltire la grafica. Sembra lo stesso principio della nuova Bitmap (immagine, larghezza, altezza) con una migliore modalità di interpolazione. Sono curioso di cosa sia Default ? È anche peggio di Low?
Sinatr,

9

Questo codice è uguale a quello pubblicato da una delle risposte precedenti .. ma convertirà il pixel trasparente in bianco anziché in nero ... Grazie :)

    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;
    }

7

Nell'applicazione che ho realizzato era necessario creare una funzione con più opzioni. È abbastanza grande, ma ridimensiona l'immagine, può mantenere le proporzioni e può tagliare i bordi per restituire solo il centro dell'immagine:

/// <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);
    }

Per facilitare l'accesso alla funzione è possibile aggiungere alcune funzioni sovraccaricate:

/// <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);
    }

Ora sono gli ultimi due booleani facoltativi da impostare. Chiamare la funzione in questo modo:

System.Drawing.Image ResizedImage = resizeImageFromFile(imageLocation, 800, 400, true, true);

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;
}

Fai clic qui http://bhupendrasinghsaini.blogspot.in/2014/07/resize-image-in-c.html


6

Questo è il codice che ho elaborato per un requisito specifico, ovvero: la destinazione è sempre in rapporto orizzontale. Dovrebbe darti un buon inizio.

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;

}

Eccezionale!!! Ero nei guai in un'immagine di ritratto e dopo aver provato molte soluzioni ricercate sul web, questo era l'UNICO che era PERFETTO! GRAZIE MILLE!
Fábio,

3

Se lavori con un BitmapSource:

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

Se desideri un controllo più preciso sulla qualità, esegui prima questo:

RenderOptions.SetBitmapScalingMode(
    bitmapSource,
    BitmapScalingMode.HighQuality);

(L'impostazione predefinita è BitmapScalingMode.Linearequivalente a BitmapScalingMode.LowQuality.)



1

Ridimensiona e salva un'immagine per adattarla a larghezza e altezza come una tela mantenendo l'immagine proporzionale

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);
                }
            }
        }
    }
}

1

Utilizzare la funzione di seguito con l'esempio di seguito per modificare le dimensioni dell'immagine:

//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;
     }
}

2
Si prega di considerare di spiegare nella risposta sopra come utilizzare questo codice, cosa fa il codice e come risolve il problema nella domanda originale.
Tim Visée,

Ho aggiunto anche il caso d'uso. Utilizzare la funzione sopra con un esempio qui sotto. Immagine newImage = Image.FromFile ("SampImag.jpg"); Image temImag = FormatImage (newImage, 100, 100);
Prasad KM,


0

Nota: questo non funzionerà con ASP.Net Core perché WebImage dipende da System.Web, ma su versioni precedenti di ASP.Net ho usato questo frammento molte volte ed è stato utile.

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");
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.