Cómo cambiar el tamaño de una imagen C #


288

Como Size, Widthy Heightson Get()propiedades de System.Drawing.Image;
¿Cómo puedo cambiar el tamaño de un objeto de imagen en tiempo de ejecución en C #?

En este momento, estoy creando un nuevo Imageuso:

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

2
No es la forma correcta ... utiliza una interpolación de baja calidad y puede hacer que la secuencia original permanezca bloqueada durante la duración de la nueva imagen de mapa de bits ... Lea la lista de dificultades de cambio de tamaño de la imagen antes de hacer su propia solución de cambio de tamaño de imagen.
Lilith River

2
¡Desecha eso! ¡Usar () {} funciona!
Scott Coates

8
Si estas respuestas son útiles, considere marcar la respuesta aceptada.
Joel

3
No es necesario usar ninguna biblioteca adicional. El código publicado a continuación por Mark funciona perfectamente.
Elmue

9
Quien es Mark No pude encontrar su respuesta, pero hay 3 comentarios que se refieren a ella.
Sinatr

Respuestas:


490

Esto realizará un cambio de tamaño de alta calidad:

/// <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) evita el efecto fantasma alrededor de los bordes de la imagen: el cambio de tamaño ingenuo muestreará píxeles transparentes más allá de los límites de la imagen, pero al reflejar la imagen podemos obtener una mejor muestra (esta configuración es muy notable)
  • destImage.SetResolution mantiene el DPI independientemente del tamaño físico; puede aumentar la calidad al reducir las dimensiones de la imagen o al imprimir
  • La composición controla cómo se mezclan los píxeles con el fondo; puede que no sea necesario ya que solo estamos dibujando una cosa.
    • graphics.CompositingModedetermina si los píxeles de una imagen de origen se sobrescriben o se combinan con píxeles de fondo. SourceCopyespecifica que cuando se representa un color, sobrescribe el color de fondo.
    • graphics.CompositingQuality determina el nivel de calidad de representación de las imágenes en capas.
  • graphics.InterpolationMode determina cómo se calculan los valores intermedios entre dos puntos finales
  • graphics.SmoothingMode especifica si las líneas, las curvas y los bordes de las áreas rellenas usan suavizado (también llamado antialiasing), probablemente solo funciona en vectores
  • graphics.PixelOffsetMode afecta la calidad de renderizado al dibujar la nueva imagen

Mantener la relación de aspecto se deja como un ejercicio para el lector (en realidad, no creo que sea el trabajo de esta función hacer eso por usted).

Además, este es un buen artículo que describe algunas de las dificultades con el cambio de tamaño de la imagen. La función anterior cubrirá la mayoría de ellos, pero aún debe preocuparse por guardar .


44
El código funcionó perfectamente al cambiar el tamaño de la imagen, pero aumentó el tamaño de 66 KB a 132 KB. ¿Cómo puedo reducirlo
Chamara

3
@chamara Eso probablemente se deba a que ahorraste la calidad que elegiste. Consulte msdn.microsoft.com/en-us/library/bb882583(v=vs.110).aspx Pruebe quality = 90
mpen el

3
@kstubs Seguro que lo eres. Bitmapes esencialmente solo el nombre de la clase, puede guardarlo como el tipo de archivo que desee.
mpen

55
@dotNetBlackBelt Probablemente necesite agregar una referencia System.Drawingy agregarlausing System.Drawing.Imaging;
mpen

2
Esto no mantendrá la relación de aspecto original, ¿verdad?
Kasper Skov

148

No estoy seguro de lo que es tan difícil sobre esto, haga lo que estaba haciendo, use el constructor de mapa de bits sobrecargado para crear una imagen redimensionada, lo único que le faltaba era una conversión al tipo de datos de imagen:

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

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

2
¿No debería deshacerse yourImageantes de asignarlo a la nueva imagen?
Nick Shaw

3
Puede desecharlo manualmente o puede dejar que el recolector de basura haga su trabajo. No importa.
Elmue

23
Este código no da control sobre la calidad del cambio de tamaño, lo cual es muy importante. Echa un vistazo a la respuesta de Mark.
Elmue

43

en esta pregunta , tendrá algunas respuestas, incluida la mía:

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

55
Olvidó imgPhoto.Dispose (); el archivo se mantiene en uso
shrutyzet

1
Esto es muy útil, y lo estoy usando en mi aplicación. Sin embargo, es importante tener en cuenta que este algoritmo no funciona con imágenes transparentes. Convierte todos los píxeles transparentes en negro. Probablemente sea fácil de arreglar, pero es solo una nota para los usuarios. :)
meme

1
¿No se supone que debes guardar la imagen? imgPhoto.Save ()?
Whiplash

@meme ¿Puedes dar un enlace sobre cómo arreglar ese fondo negro para un documento transparente?
Syed Mohamed

25

¿Por qué no usar el System.Drawing.Image.GetThumbnailImagemétodo?

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

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


66
Esta no es la forma correcta de cambiar el tamaño de una imagen. Esto extrae una miniatura del jpg si existe. Si no existe, no tiene control sobre la calidad o la nueva imagen. Además, este código tiene pérdidas de memoria.
Robert Smith

1
@Bobrot ¿Por qué esto causará pérdidas de memoria?
usuario

2
Cualquier cosa en la biblioteca GDI todavía se está ejecutando sin administrar. Sin usar una declaración de uso o desechar los objetos después, el sistema puede tardar mucho tiempo en recolectar basura de esos objetos y hacer que la memoria esté disponible nuevamente.
Robert Smith

9
Es como usted dice: puede llevar mucho tiempo. Pero esto NO es una pérdida de memoria. Sería una pérdida de memoria si la memoria NUNCA se liberaría. Pero este es el comportamiento NORMAL del recolector de basura que libera memoria cuando la CPU está inactiva. La instrucción using () no evita pérdidas de memoria. Simplemente libera la memoria de inmediato, mientras que el recolector de basura libera la memoria cuando tiene tiempo para hacerlo. Esa es la única diferencia en este caso específico.
Elmue

Vea las trampas del cambio de tamaño de la imagen: nathanaeljones.com/blog/2009/20-image-resizing-pitfalls "Usar GetThumbnailImage (). GetThumbnailImage () parece la opción obvia, y muchos artículos recomiendan su uso. Desafortunadamente, siempre toma el jpeg incrustado miniatura si está presente. Algunas fotos tienen estas, otras no, generalmente depende de su cámara. Se preguntará por qué GetThumbnailImage funciona bien en algunas fotos, pero en otras está terriblemente borroso. GetThumbnailImage () no es confiable para fotos más grandes por 10 px por 10 px por ese motivo ".
Nick Painter

12

Puede probar net-vips , el enlace de C # para libvips . Es una biblioteca de procesamiento de imágenes perezosa, de transmisión y basada en la demanda, por lo que puede realizar operaciones como esta sin necesidad de cargar toda la imagen.

Por ejemplo, viene con una práctica imagen en miniatura:

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

También es compatible con el recorte inteligente, una forma de determinar de manera inteligente la parte más importante de la imagen y mantenerla enfocada mientras recorta la imagen. Por ejemplo:

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

Donde owl.jpghay una composición descentrada:

Búho

Da este resultado:

Cultivo inteligente de búho

Primero, reduce la imagen para obtener el eje vertical a 128 píxeles, luego se reduce a 128 píxeles utilizando la attentionestrategia. Este busca en la imagen las características que podrían captar la atención de un humano, vea los Smartcrop()detalles.


Tu unión para libvips parece genial. Definitivamente voy a echar un vistazo a tu lib. ¡Gracias por poner esto a disposición del desarrollador de C #!
FrenchTastic

Esto es excelente! No tenía idea de que una biblioteca de procesamiento de imágenes pudiera verse tan bien.
dalvir

¡bonito! mejor que ImageMagick heavy
Moshe L

10

Esta voluntad -

  • Cambiar el tamaño del ancho y la altura sin la necesidad de un bucle
  • No supera las dimensiones originales de las imágenes.

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

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 estaba preguntando sobre System.Drawing.Image, donde su código no funcionará ya que las propiedades 'Ancho' y 'Altura' no son configurables. Sin embargo, funcionará para 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;
}

Olvidó deshacerse de los gráficos. Parece el mismo principio que el nuevo Bitmap (imagen, ancho, alto) con un mejor modo de interpolación. Tengo curiosidad por saber qué es predeterminado ? ¿Es peor incluso que Low?
Sinatr

9

Este código es el mismo que el publicado en una de las respuestas anteriores ... pero convertirá píxeles transparentes a blanco en lugar de negro ... Gracias :)

    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

En la aplicación que hice fue necesario crear una función con múltiples opciones. Es bastante grande, pero cambia el tamaño de la imagen, puede mantener la relación de aspecto y puede cortar los bordes para devolver solo el centro de la imagen:

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

Para facilitar el acceso a la función, es posible agregar algunas funciones sobrecargadas:

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

Ahora son los dos últimos booleanos opcionales para establecer. Llame a la función así:

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

Haga clic aquí http://bhupendrasinghsaini.blogspot.in/2014/07/resize-image-in-c.html


6

Este es el código que elaboré para un requisito específico, es decir: el destino siempre está en relación horizontal. Debería darte un buen comienzo.

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;

}

¡¡¡Increíble!!! Estaba en problemas en una imagen de retrato y después de probar muchas soluciones buscadas en la web, ¡esta fue la ÚNICA PERFECTA! ¡MUCHAS GRACIAS!
Fábio

3

Si estás trabajando con un BitmapSource:

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

Si desea un control más fino sobre la calidad, ejecute esto primero:

RenderOptions.SetBitmapScalingMode(
    bitmapSource,
    BitmapScalingMode.HighQuality);

(El valor predeterminado es BitmapScalingMode.Linearel equivalente a BitmapScalingMode.LowQuality).



1

Cambiar el tamaño y guardar una imagen para que se ajuste a ancho y alto como un lienzo manteniendo la imagen proporcional

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

Utilice la siguiente función con el siguiente ejemplo para cambiar el tamaño de la imagen:

//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
Considere explicar en su respuesta anterior cómo usar este código, qué hace el código y cómo resuelve el problema en la pregunta original.
Tim Visée

He agregado el caso de uso también. Utilice la función anterior con el siguiente ejemplo. Imagen newImage = Image.FromFile ("SampImag.jpg"); Imagen temImag = FormatImage (newImage, 100, 100);
Prasad KM


0

Nota: esto no funcionará con ASP.Net Core porque WebImage depende de System.Web, pero en versiones anteriores de ASP.Net usé este fragmento muchas veces y fue útil.

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");
}
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.