Comment redimensionner une image en C#

Question

Como Size , Width y Height sont Get() les propriétés de System.Drawing.Image ;
Comment puis-je redimensionner un objet Image au moment de l'exécution en C# ?

Pour l'instant, je crée juste un nouveau Image en utilisant :

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

Answer 1

Cela permettra d'effectuer 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 frontières de l'image -- un redimensionnement naïf échantillonnera les pixels transparents au-delà des frontières 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 augmenter 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 à l'arrière-plan. Elle n'est peut-être pas nécessaire puisque nous ne dessinons qu'une seule chose.
  • graphics.CompositingMode détermine si les pixels d'une image source remplacent ou sont combinés avec les pixels de l'arrière-plan. SourceCopy spécifie que lorsqu'une couleur est rendue, elle écrase la couleur d'arrière-plan.
  • graphics.CompositingQuality détermine le niveau de qualité du rendu des images en couches.
• graphics.InterpolationMode détermine le mode de calcul des valeurs intermédiaires entre deux points d'extrémité
• graphics.SmoothingMode spécifie si les lignes, les courbes et les bords des zones remplies utilisent le lissage (également appelé anti-cré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 ratio d'aspect est laissé comme un exercice pour le lecteur (en fait, je ne pense pas que ce soit le rôle de cette fonction de le faire pour vous).

Aussi, c'est un bon article décrivant certains des pièges du redimensionnement des images. La fonction ci-dessus couvre la plupart d'entre eux, mais vous devez toujours vous préoccuper de ce qui suit sauver .

Answer 2

Je ne vois pas ce qui est si difficile, 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 transfert vers le 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));

Answer 3

Sur cette question vous aurez des réponses, y compris les miennes :

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

Answer 4

Pourquoi ne pas utiliser le System.Drawing.Image.GetThumbnailImage méthode ?

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

Ejemplo:

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

Answer 5

Créer un nouveau Bitmap dans la nouvelle taille, obtenez un Graphiques de l'objet, définissez InterpolationMode et utiliser DrawImage pour peindre l'image originale dans la nouvelle image à la nouvelle taille.