c# - redimensionar - Cambiar el tamaño de la imagen proporcionalmente con las restricciones MaxHeight y MaxWidth

hacer que una imagen se adapte a un div

Question

Usando System.Drawing.Image .

Si el ancho o la altura de una imagen exceden el máximo, es necesario cambiar el tamaño proporcionalmente. Después de cambiar de tamaño, debe asegurarse de que ni el ancho ni la altura excedan el límite.

El ancho y la altura se cambiarán de tamaño hasta que no se exceda al máximo y al mínimo automáticamente (mayor tamaño posible) y también se mantenga la relación.

Answer 1

¿Me gusta esto?

public static void Test()
{
    using (var image = Image.FromFile(@"c:/logo.png"))
    using (var newImage = ScaleImage(image, 300, 400))
    {
        newImage.Save(@"c:/test.png", ImageFormat.Png);
    }
}

public static Image ScaleImage(Image image, int maxWidth, int maxHeight)
{
    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);

    using (var graphics = Graphics.FromImage(newImage))
        graphics.DrawImage(image, 0, 0, newWidth, newHeight);

    return newImage;
}

Answer 2

Solución de trabajo:

Para cambiar el tamaño de la imagen con un tamaño inferior a 100 KB

WriteableBitmap bitmap = new WriteableBitmap(140,140);
bitmap.SetSource(dlg.File.OpenRead());
image1.Source = bitmap;

Image img = new Image();
img.Source = bitmap;
WriteableBitmap i;

do
{
    ScaleTransform st = new ScaleTransform();
    st.ScaleX = 0.3;
    st.ScaleY = 0.3;
    i = new WriteableBitmap(img, st);
    img.Source = i;
} while (i.Pixels.Length / 1024 > 100);

Más referencia en http://net4attack.blogspot.com/

Answer 3

Solución mucho más larga, pero tiene en cuenta los siguientes escenarios:

1. ¿Es la imagen más pequeña que el cuadro delimitador?
2. ¿Son cuadradas la imagen y la caja delimitadora?
3. Es la imagen cuadrada y el cuadro delimitador no es
4. Es la imagen más ancha y más alta que el cuadro delimitador
5. Es la imagen más ancha que el cuadro delimitador

6. Es la imagen más alta que el cuadro delimitador

   private Image ResizePhoto(FileInfo sourceImage, int desiredWidth, int desiredHeight)
   {
       //throw error if bouning box is to small
       if (desiredWidth < 4 || desiredHeight < 4)
           throw new InvalidOperationException("Bounding Box of Resize Photo must be larger than 4X4 pixels.");            
       var original = Bitmap.FromFile(sourceImage.FullName);
   
       //store image widths in variable for easier use
       var oW = (decimal)original.Width;
       var oH = (decimal)original.Height;
       var dW = (decimal)desiredWidth;
       var dH = (decimal)desiredHeight;
   
       //check if image already fits
       if (oW < dW && oH < dH)
           return original; //image fits in bounding box, keep size (center with css) If we made it bigger it would stretch the image resulting in loss of quality.
   
       //check for double squares
       if (oW == oH && dW == dH)
       {
           //image and bounding box are square, no need to calculate aspects, just downsize it with the bounding box
           Bitmap square = new Bitmap(original, (int)dW, (int)dH);
           original.Dispose();
           return square;
       }
   
       //check original image is square
       if (oW == oH)
       {
           //image is square, bounding box isn''t.  Get smallest side of bounding box and resize to a square of that center the image vertically and horizontally with Css there will be space on one side.
           int smallSide = (int)Math.Min(dW, dH);
           Bitmap square = new Bitmap(original, smallSide, smallSide);
           original.Dispose();
           return square;
       }
   
       //not dealing with squares, figure out resizing within aspect ratios            
       if (oW > dW && oH > dH) //image is wider and taller than bounding box
       {
           var r = Math.Min(dW, dH) / Math.Min(oW, oH); //two dimensions so figure out which bounding box dimension is the smallest and which original image dimension is the smallest, already know original image is larger than bounding box
           var nH = oH * r; //will downscale the original image by an aspect ratio to fit in the bounding box at the maximum size within aspect ratio.
           var nW = oW * r;
           var resized = new Bitmap(original, (int)nW, (int)nH);
           original.Dispose();
           return resized;
       }
       else
       {
           if (oW > dW) //image is wider than bounding box
           {
               var r = dW / oW; //one dimension (width) so calculate the aspect ratio between the bounding box width and original image width
               var nW = oW * r; //downscale image by r to fit in the bounding box...
               var nH = oH * r;
               var resized = new Bitmap(original, (int)nW, (int)nH);
               original.Dispose();
               return resized;
           }
           else
           {
               //original image is taller than bounding box
               var r = dH / oH;
               var nH = oH * r;
               var nW = oW * r;
               var resized = new Bitmap(original, (int)nW, (int)nH);
               original.Dispose();
               return resized;
           }
       }
   }