Comment redimensionner une image C #


288

Comme Size, Widthet Heightsont des Get()propriétés de System.Drawing.Image;
Comment puis-je redimensionner un objet Image au moment de l'exécution en C #?

En ce moment, je suis juste en train de créer une nouvelle en Imageutilisant:

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

2
Pas la bonne façon ... utilise une interpolation de faible qualité et peut bloquer le flux d'origine pendant la durée de la nouvelle image bitmap ... Lisez la liste des pièges de redimensionnement d'image avant de faire votre propre solution de redimensionnement d'image.
Lilith River

2
Jetez ça! L'utilisation de () {} fonctionne!
Scott Coates

8
Si ces réponses sont utiles, pensez à marquer la réponse acceptée.
Joel

3
Il n'est pas nécessaire d'utiliser une bibliothèque supplémentaire. Le code affiché ci-dessous par Mark fonctionne parfaitement.
Elmue

9
Qui est Mark? Je n'ai pas trouvé sa réponse, mais il y a 3 commentaires qui s'y réfèrent.
Sinatr

Réponses:


490

Cela effectuera un redimensionnement de haute 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) empêche les images fantômes autour des bords de l'image - un redimensionnement naïf échantillonnera les pixels transparents au-delà des limites de l'image, mais en reflétant l'image, nous pouvons obtenir un meilleur échantillon (ce paramètre est très visible)
  • destImage.SetResolution maintient le DPI indépendamment de la taille physique - peut améliorer la qualité lors de la réduction des dimensions de l'image ou lors de l'impression
  • La composition contrôle la façon dont les pixels sont mélangés avec l'arrière-plan - peut ne pas être nécessaire car nous ne dessinons qu'une seule chose.
    • graphics.CompositingModedétermine si les pixels d'une image source doivent être remplacés ou combinés avec des pixels d'arrière-plan. SourceCopyspécifie que lorsqu'une couleur est rendue, elle remplace la couleur d'arrière-plan.
    • graphics.CompositingQuality détermine le niveau de qualité de rendu des images en couches.
  • graphics.InterpolationMode détermine comment les valeurs intermédiaires entre deux points d'extrémité sont calculées
  • graphics.SmoothingMode spécifie si les lignes, les courbes et les bords des zones remplies utilisent le lissage (également appelé anticrénelage) - ne fonctionne probablement que sur les vecteurs
  • graphics.PixelOffsetMode affecte la qualité du rendu lors du dessin de la nouvelle image

Le maintien du rapport d'aspect est laissé comme un exercice pour le lecteur (en fait, je ne pense pas que ce soit le travail de cette fonction de le faire pour vous).

En outre, c'est un bon article décrivant certains des pièges du redimensionnement d'image. La fonction ci-dessus couvrira la plupart d'entre eux, mais vous devez toujours vous soucier de l' enregistrement .


4
le code a parfaitement fonctionné lors du redimensionnement de l'image mais a augmenté la taille de 66 Ko à 132 Ko. Hoe puis-je le réduire
chamara

3
@chamara Cela est probablement dû à la qualité que vous avez choisie. Voir msdn.microsoft.com/en-us/library/bb882583(v=vs.110).aspx Try quality = 90
mpen

3
@kstubs Vous êtes sûr. Bitmapest essentiellement le nom de la classe, vous pouvez l'enregistrer sous le type de fichier que vous souhaitez.
mpen

5
@dotNetBlackBelt Vous devrez probablement ajouter une référence à System.Drawinget ajouterusing System.Drawing.Imaging;
mpen

2
Cela ne maintiendra pas le rapport hauteur / largeur d'origine non?
Kasper Skov

148

Vous ne savez pas ce qui est si difficile à faire, faites ce que vous faisiez, utilisez le constructeur Bitmap surchargé pour créer une image redimensionnée, la seule chose qui vous manquait était un retour au type de données Image:

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

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

2
Ne devriez-vous pas vous débarrasser yourImageavant de l'assigner à la nouvelle image?
Nick Shaw

3
Vous pouvez le jeter manuellement ou laisser le garbage collector faire son travail. Peu importe.
Elmue

23
Ce code ne donne aucun contrôle sur la qualité du redimensionnement qui est très important. Jetez un œil à la réponse de Mark.
Elmue

43

dans cette question , vous aurez quelques réponses, dont la mienne:

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
Vous avez oublié imgPhoto.Dispose (); le fichier est conservé
shrutyzet

1
C'est très utile et j'utilise ceci dans mon application. Cependant, il est important de noter que cet algorithme ne fonctionne pas avec les images transparentes. Il transforme tous les pixels transparents en noir. C'est probablement facile à réparer, mais c'est juste une note pour les utilisateurs. :)
meme

1
N'êtes-vous pas censé enregistrer l'image? imgPhoto.Save ()?
Whiplash

@meme Pouvez-vous donner un lien sur la façon de corriger ce fond noir pour un document transparent.
Syed Mohamed

25

Pourquoi ne pas utiliser la System.Drawing.Image.GetThumbnailImageméthode?

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

Exemple:

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

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


6
Ce n'est pas la bonne façon de redimensionner une image. Cela extrait une miniature du jpg s'il existe. S'il n'existe pas, vous n'avez aucun contrôle sur la qualité ou la nouvelle image. En outre, ce code contient des fuites de mémoire.
Robert Smith

1
@Bobrot Pourquoi cela entraînera-t-il des fuites de mémoire?
utilisateur

2
Tout ce qui se trouve dans la bibliothèque GDI fonctionne toujours sans être géré. Sans utiliser une instruction using ou éliminer les objets par la suite, le système peut prendre beaucoup de temps pour récupérer ces objets et rendre la mémoire disponible à nouveau.
Robert Smith

9
C'est comme vous le dites: cela peut prendre beaucoup de temps. Mais ce n'est PAS une fuite de mémoire. Ce serait une fuite de mémoire si la mémoire n'était jamais libérée. Mais c'est le comportement NORMAL du garbage collector qu'il libère de la mémoire lorsque le CPU est inactif. L'instruction using () n'empêche pas les fuites de mémoire. Il libère juste la mémoire immédiatement tandis que le garbage collector libère la mémoire quand il a le temps de le faire. C'est la seule différence dans ce cas précis.
Elmue

Voir les pièges du redimensionnement d'image: nathanaeljones.com/blog/2009/20-image-resizing-pitfalls "Utiliser GetThumbnailImage (). GetThumbnailImage () semble le choix évident, et de nombreux articles recommandent son utilisation. Malheureusement, il récupère toujours le jpeg intégré miniature si présente. Certaines photos en ont, d'autres non - cela dépend généralement de votre appareil photo. Vous vous demanderez pourquoi GetThumbnailImage fonctionne bien sur certaines photos, mais sur d'autres est horriblement floue. GetThumbnailImage () n'est pas fiable pour les photos plus grandes que 10px par 10px pour cette raison. "
Nick Painter

12

Vous pouvez essayer net-vips , la liaison C # pour libvips . Il s'agit d'une bibliothèque de traitement d'image paresseuse, en streaming et axée sur la demande, de sorte qu'elle peut effectuer des opérations comme celle-ci sans avoir besoin de charger l'image entière.

Par exemple, il est livré avec un imageur d'images pratique:

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

Il prend également en charge le recadrage intelligent, un moyen de déterminer intelligemment la partie la plus importante de l'image et de la garder au point tout en recadrant l'image. Par exemple:

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

owl.jpgest une composition excentrée:

Hibou

Donne ce résultat:

Chouette smart crop

Tout d'abord, il réduit l'image pour obtenir l'axe vertical à 128 pixels, puis recadre à 128 pixels en utilisant la attentionstratégie. Celui-ci recherche dans l'image les caractéristiques susceptibles d'attirer l'attention de l'homme, voir Smartcrop()pour plus de détails.


Votre liaison pour libvips semble excellente. Je vais certainement jeter un œil à votre bibliothèque. Merci d'avoir mis cela à la disposition du développeur C #!
FrenchTastic

C'est superbe! Je n'avais aucune idée qu'une bibliothèque de traitement d'image pourrait être aussi belle.
dalvir

agréable! mieux que ImageMagick heavy
Moshe L

10

Cette volonté -

  • Redimensionnez la largeur ET la hauteur sans avoir besoin d'une boucle
  • Ne dépasse pas les dimensions originales des images

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

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 posait des questions sur System.Drawing.Image, où votre code ne fonctionnera pas car les propriétés 'Width' et 'Height' ne sont pas réglables. Il fonctionnera cependant pour 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;
}

Vous avez oublié de supprimer les graphiques. Semble le même principe que le nouveau Bitmap (image, largeur, hauteur) avec un meilleur mode d'interpolation. Je suis curieux de savoir ce qu'est Default ? Est-ce pire encore que ça Low?
Sinatr

9

Ce code est le même que celui publié dans l'une des réponses ci-dessus .. mais convertira le pixel transparent en blanc au lieu de noir ... Merci :)

    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

Dans l'application que j'ai faite, il était nécessaire de créer une fonction avec plusieurs options. Il est assez grand, mais il redimensionne l'image, peut conserver les proportions et couper les bords pour ne renvoyer que le centre de l'image:

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

Pour faciliter l'accès à la fonction, il est possible d'ajouter des fonctions surchargées:

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

Les deux derniers booléens sont maintenant facultatifs à définir. Appelez la fonction comme ceci:

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

Cliquez ici http://bhupendrasinghsaini.blogspot.in/2014/07/resize-image-in-c.html


6

C'est le code que j'ai élaboré pour une exigence spécifique, c'est-à-dire: la destination est toujours en format paysage. Cela devrait vous donner un bon départ.

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;

}

Impressionnant!!! J'étais en difficulté dans une image portrait et après avoir essayé de nombreuses solutions recherchées sur le web, c'était la SEULE qui était PARFAITE! MERCI BEAUCOUP!
Fábio

3

Si vous travaillez avec un BitmapSource:

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

Si vous souhaitez un contrôle plus fin de la qualité, exécutez d'abord ceci:

RenderOptions.SetBitmapScalingMode(
    bitmapSource,
    BitmapScalingMode.HighQuality);

(La valeur par défaut est BitmapScalingMode.Linearéquivalente à BitmapScalingMode.LowQuality.)


3

J'utilise ImageProcessorCore, principalement parce qu'il fonctionne avec .Net Core.

Et il a plus d'options telles que la conversion de types, le recadrage d'images et plus encore

http://imageprocessor.org/imageprocessor/


1
J'ai regardé et cela ne prend pas en charge .NET Core. Il est construit contre le cadre complet.
chrisdrobison

1

Redimensionnez et enregistrez une image pour l'adapter à la largeur et à la hauteur comme une toile en gardant l'image proportionnelle

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

Utilisez la fonction ci-dessous avec l'exemple ci-dessous pour changer la taille de l'image:

//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
Veuillez envisager d'expliquer dans votre réponse ci-dessus comment utiliser ce code, ce que fait le code et comment il résout le problème dans la question d'origine.
Tim Visée

J'ai également ajouté un cas d'utilisation. Utilisez la fonction ci-dessus avec l'exemple ci-dessous. Image newImage = Image.FromFile ("SampImag.jpg"); Image temImag = FormatImage (newImage, 100, 100);
Prasad KM


0

Remarque: cela ne fonctionnera pas avec ASP.Net Core car WebImage dépend de System.Web, mais sur les versions précédentes d'ASP.Net, j'ai utilisé cet extrait de code à plusieurs reprises et m'a été 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");
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.