Como redimensionar uma imagem C #

288

Como Size, Widthe Heightsão Get()propriedades de System.Drawing.Image;
Como posso redimensionar um objeto de imagem em tempo de execução em c #?

No momento, estou apenas criando um novo Imageuso:

// objImage is the original Image
Bitmap objBitmap = new Bitmap(objImage, new Size(227, 171));
inutan
fonte
2
Não é o caminho certo ... usa interpolação de baixa qualidade e pode fazer com que o fluxo original fique bloqueado durante a nova imagem de bitmap ... Leia a lista de armadilhas para redimensionar a imagem antes de fazer sua própria solução de redimensionamento de imagem.
Lilith River
2
Descarte isso! Usar () {} funciona!
Scott Coates
8
Se essas respostas forem úteis, marque a resposta aceita.
Joel
3
Não há necessidade de usar nenhuma biblioteca adicional. O código postado abaixo por Mark funciona perfeitamente.
Elmue 23/09
9
Quem é Mark? Não consegui encontrar sua resposta, mas existem 3 comentários que se referem a ela.
Sinatr 10/01/19

Respostas:

490

Isso executará um redimensionamento de alta qualidade:

/// <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 fantasmas nas bordas da imagem - o redimensionamento ingênuo mostra pixels transparentes além dos limites da imagem, mas espelhando a imagem, podemos obter uma amostra melhor (essa configuração é muito perceptível)
  • destImage.SetResolution mantém o DPI independentemente do tamanho físico - pode aumentar a qualidade ao reduzir as dimensões da imagem ou ao imprimir
  • A composição controla como os pixels são combinados com o plano de fundo - pode não ser necessário, pois estamos desenhando apenas uma coisa.
    • graphics.CompositingModedetermina se os pixels de uma imagem de origem serão substituídos ou combinados com os pixels de fundo. SourceCopyespecifica que quando uma cor é renderizada, ela substitui a cor do plano de fundo.
    • graphics.CompositingQuality determina o nível de qualidade de renderização das imagens em camadas.
  • graphics.InterpolationMode determina como os valores intermediários entre dois pontos de extremidade são calculados
  • graphics.SmoothingMode especifica se as linhas, curvas e as bordas das áreas preenchidas usam suavização (também chamada antialiasing) - provavelmente só funciona em vetores
  • graphics.PixelOffsetMode afeta a qualidade da renderização ao desenhar a nova imagem

Manter a proporção é deixada como um exercício para o leitor (na verdade, acho que não é o trabalho dessa função fazer isso por você).

Além disso, este é um bom artigo que descreve algumas das armadilhas com o redimensionamento de imagens. A função acima cobrirá a maioria deles, mas você ainda precisa se preocupar em economizar .

mpen
fonte
4
O código funcionou perfeitamente ao redimensionar a imagem, mas aumentou o tamanho de 66 KB para 132 KB. Hoe posso reduzi-la
chamara
3
@chamara Isso provavelmente se deve à qualidade que você escolheu. Veja msdn.microsoft.com/en-us/library/bb882583(v=vs.110).aspx qualidade Try = 90
MPEN
3
@kstubs Você com certeza é. Bitmapé essencialmente apenas o nome da classe, você pode salvá-lo como qualquer tipo de arquivo que desejar.
MPEN
5
@dotNetBlackBelt Você provavelmente precisará adicionar uma referência a System.Drawinge adicioneusing System.Drawing.Imaging;
MPEN
2
Isso não manterá a proporção original, certo?
Kasper Skov
148

Não tenho certeza do que é tão difícil nisso, faça o que estava fazendo, use o construtor Bitmap sobrecarregado para criar uma imagem redimensionada, a única coisa que estava faltando era uma conversão ao tipo de dados Image:

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

    yourImage = resizeImage(yourImage, new Size(50,50));
Matt
fonte
2
Você não deve descartá-lo yourImageantes de atribuí-lo à nova imagem?
Nick Shaw
3
Você pode descartá-lo manualmente ou deixar o coletor de lixo fazer seu trabalho. Não importa.
Elmue 23/09
23
Este código não dá controle sobre a qualidade do redimensionamento, o que é muito importante. Dê uma olhada na resposta de Mark.
Elmue 23/09
42

em esta pergunta , você vai ter algumas respostas, incluindo a minha:

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
fonte
5
Você esqueceu imgPhoto.Dispose (); o arquivo é mantido em uso
shrutyzet
1
Isso é muito útil, e eu estou usando isso no meu aplicativo. No entanto, é importante observar que esse algoritmo não funciona com imagens transparentes. Ele transforma todos os pixels transparentes em preto. Provavelmente é fácil de corrigir, mas é apenas uma nota para os usuários. :)
meme
1
Você não deveria salvar a imagem? imgPhoto.Save ()?
Whiplash
@meme Você pode dar um link sobre como corrigir esse fundo preto para um documento transparente.
Syed Mohamed
25

Por que não usar o System.Drawing.Image.GetThumbnailImagemétodo?

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

Exemplo:

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

Lino Silva
fonte
6
Esta não é a maneira correta de redimensionar uma imagem. Isso puxa uma miniatura do jpg, se existir. Se não existir, você não terá controle sobre a qualidade ou a nova imagem. Além disso, esse código como está possui vazamentos de memória.
Robert Smith
1
@Bobrot Por que isso causa vazamentos de memória?
usuário
2
Qualquer coisa na biblioteca GDI ainda está sendo executada não gerenciada. Sem usar uma declaração de uso ou descartar os objetos posteriormente, pode levar muito tempo para o sistema coletar esses objetos e disponibilizar a memória novamente.
Robert Smith
9
É como você diz: pode levar muito tempo. Mas isso NÃO é um vazamento de memória. Seria um vazamento de memória se a memória nunca seria liberada. Mas esse é o comportamento NORMAL do coletor de lixo que libera memória quando a CPU está ociosa. A instrução using () não impede vazamentos de memória. Ele libera a memória imediatamente, enquanto o coletor de lixo libera a memória quando há tempo para fazer isso. Essa é a única diferença neste caso específico.
Elmue
Veja as armadilhas do redimensionamento de imagem: nathanaeljones.com/blog/2009/20-image-resizing-pitfalls "Usando GetThumbnailImage (). GetThumbnailImage () parece a escolha óbvia e muitos artigos recomendam seu uso. Infelizmente, ele sempre pega o jpeg incorporado miniaturas se presentes. Algumas fotos têm isso, outras não - geralmente depende da sua câmera. Você se perguntará por que GetThumbnailImage funciona bem em algumas fotos, mas em outras fica terrivelmente desfocado. GetThumbnailImage () não é confiável para fotos maiores 10 x 10 por esse motivo ".
perfil completo de Nick Painter
12

Você pode tentar net-vips , a ligação de C # para libvips . É uma biblioteca de processamento de imagens preguiçosa, de fluxo contínuo e orientada por demanda, para que possa executar operações como essa sem precisar carregar a imagem inteira.

Por exemplo, ele vem com um prático miniaturizador de imagens:

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

Ele também suporta corte inteligente, uma maneira de determinar de forma inteligente a parte mais importante da imagem e mantê-la focada durante o corte da imagem. Por exemplo:

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

Onde owl.jpgestá uma composição descentralizada:

Coruja

Dá este resultado:

Coruja inteligente colheita

Primeiro, reduz a imagem para obter o eixo vertical para 128 pixels, depois corta para 128 pixels usando a attentionestratégia. Este pesquisa na imagem recursos que possam chamar a atenção de um humano, veja Smartcrop()detalhes.

kleisauke
fonte
Sua ligação para libvips parece ótima. Definitivamente vou dar uma olhada na sua biblioteca. Obrigado por disponibilizar isso ao desenvolvedor do C #!
FrenchTastic
Isso é excelente! Eu não tinha ideia de que uma biblioteca de processamento de imagens pudesse parecer tão boa.
21819 dalvir
legais! melhor que o ImageMagick pesado
Moshe L
10

Isso vai -

  • Redimensionar largura e altura sem a necessidade de um loop
  • Não excede as dimensões originais das imagens

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

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
fonte
11
O OP estava perguntando sobre System.Drawing.Image, onde seu código não funcionará, pois as propriedades 'Width' e 'Height' não são configuráveis. No entanto, ele 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;
}
NeoSvet
fonte
Você esqueceu de descartar gráficos. Parece o mesmo princípio que o novo Bitmap (imagem, largura, altura) com melhor modo de interpolação. Estou curioso para saber o que é padrão . É pior do que isso Low?
Sinatr 10/01/19
9

Este código é o mesmo que postado em uma das respostas acima .. mas converterá pixel transparente em branco em vez de preto ... Obrigado :)

    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
fonte
7

Na aplicação que fiz foi necessário criar uma função com várias opções. É muito grande, mas redimensiona a imagem, pode manter a proporção e cortar as bordas para retornar apenas o centro da imagem:

/// <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 o acesso à função, é possível adicionar algumas funções sobrecarregadas:

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

Agora, os dois últimos booleanos são opcionais para definir. Chame a função assim:

System.Drawing.Image ResizedImage = resizeImageFromFile(imageLocation, 800, 400, true, true);
Quispie
fonte
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;
}

Clique aqui http://bhupendrasinghsaini.blogspot.in/2014/07/resize-image-in-c.html

bhupendra singh
fonte
6

Este é o código que desenvolvi para um requisito específico, ou seja: o destino está sempre na proporção de paisagem. Isso deve lhe dar um bom começo.

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
fonte
Impressionante!!! Eu estava com problemas em uma imagem de retrato e, depois de tentar muitas soluções procuradas na web, esse foi o ÚNICO PERFEITO! MUITO OBRIGADO!
Fábio
3

Se você estiver trabalhando com um BitmapSource:

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

Se você deseja um controle mais preciso sobre a qualidade, execute isso primeiro:

RenderOptions.SetBitmapScalingMode(
    bitmapSource,
    BitmapScalingMode.HighQuality);

(O padrão é BitmapScalingMode.Linearequivalente a BitmapScalingMode.LowQuality.)

Mateen Ulhaq
fonte
3

Eu uso o ImageProcessorCore, principalmente porque funciona .Net Core.

E tem mais opções, como converter tipos, cortar imagens e muito mais

http://imageprocessor.org/imageprocessor/

topolm
fonte
1
Eu olhei e isso não suporta o .NET Core. Ele é construído contra a estrutura completa.
Chrisdrobison #
1

Redimensione e salve uma imagem para caber na largura e altura, como uma tela, mantendo a imagem 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);
                }
            }
        }
    }
}
Andrew Paes
fonte
1

Use a função abaixo com o exemplo abaixo para alterar o tamanho da imagem:

//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
fonte
2
Por favor, considere explicar em sua resposta acima como usar esse código, o que o código faz e como ele resolve o problema na pergunta original.
Tim Visée 17/01/19
Também adicionei caso de uso. Use a função acima com o exemplo abaixo. Imagem newImage = Image.FromFile ("SampImag.jpg"); Imagem temImag = FormatImage (newImage, 100, 100);
Prasad KM #
0

Nota: isso não funcionará com o ASP.Net Core porque o WebImage depende do System.Web, mas nas versões anteriores do ASP.Net eu usei esse trecho várias vezes e foi ú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");
}
JoshYates1980
fonte