¿Cómo puedo escribir una aplicación que va a recortar imágenes en C#?

InformationsquelleAutor sandy101 | 2009-04-09

14 Comentarios

  1. 219

    Puede utilizar Gráficos.DrawImage para dibujar una imagen recortada sobre el objeto de gráficos de mapa de bits.

    Rectangle cropRect = new Rectangle(...);
    Bitmap src = Image.FromFile(fileName) as Bitmap;
    Bitmap target = new Bitmap(cropRect.Width, cropRect.Height);
    
    using(Graphics g = Graphics.FromImage(target))
    {
       g.DrawImage(src, new Rectangle(0, 0, target.Width, target.Height), 
                        cropRect,                        
                        GraphicsUnit.Pixel);
    }
    • Sólo una nota, la firma de DrawImage() no es válido. falta el GraphicsUnit parámetro.
    • También el segundo argumento es el destino rect, no el cultivo rect.
    • Es el método DrawImageUnscaledAndClipped más eficiente que DrawImage para recortar propósito?
  2. 252

    Echa un vistazo a este enlace: http://www.switchonthecode.com/tutorials/csharp-tutorial-image-editing-saving-cropping-and-resizing

    private static Image cropImage(Image img, Rectangle cropArea)
    {
       Bitmap bmpImage = new Bitmap(img);
       return bmpImage.Clone(cropArea, bmpImage.PixelFormat);
    }
    • De acuerdo, pero tenga en cuenta que si el cropArea cruza img de los límites, se da una «memoria» de excepción.
    • Este método es más rápido que @DanielLeCheminant método?
    • ambos de ellos son bastante lenta si desea recortar una imagen grande en otros más pequeños.
    • puede usted explicar más? o dar una solución para ese problema?
    • Supongo que la solución es asegurarse de que su dimensiones del rectángulo son no más grande que el de la imagen
    • Slooooowwwwwwww
    • sí, lo siento, siempre me llevó a responder de nuevo.
    • Su sitio está abajo. Alguien tiene el código de la página?
    • Esta es la peor solución para el rendimiento. Gráficos.DrawImage solución es mucho mejor.
    • El enlace no funciona ….
    • Está disponible a través de la Wayback Machine: web.archive.org/web/20120420110925/http://…

  3. 45

    Más simple que el aceptado respuesta es esta:

    public static Bitmap cropAtRect(this Bitmap b, Rectangle r)
    {
      Bitmap nb = new Bitmap(r.Width, r.Height);
      Graphics g = Graphics.FromImage(nb);
      g.DrawImage(b, -r.X, -r.Y);
      return nb;
    }

    y evita el «de memoria» excepción riesgo de que la respuesta más simple.

    EDITAR: me parece que esto está bien con los archivos Png salvado por Bitmap.Save o Paint.exe pero falla con los archivos Png guardado, por ejemplo, por Paint Shop Pro 6 – el contenido es desplazadas. Además de GraphicsUnit.Pixel les da otro mal resultado. Tal vez solo de estos errores los archivos Png son defectuosos.

    • Mejor respuesta aquí, este debe ser galardonado con la respuesta. Yo estaba experimentando el «fuera de memoria», así como en otras soluciones. Este funcionado a la primera.
    • No entiendo por qué la adición de GraphicsUnit.Pixel da mal resultado, pero sin duda es así.
    • Mis imágenes se recorte con el tamaño correcto, pero en la incorrecta X/Y hasta me llamó SetResolution en la imagen de destino, como se sugiere en la respuesta por @IntellyDev.
    • Esta respuesta fugas de la Grphics objeto.
    • Bitmap y Graphics son IDisposable – añadir una using cláusula
  4. 7

    uso bmp.SetResolution(la imagen.HorizontalResolution, de la imagen .VerticalResolution);

    esto puede ser necesario para hacer aún en el caso de implementar la mejor respuesta aquí
    sobre todo si la imagen es verdadera y resoluciones no son exactamente 96.0

    Mi ejemplo de prueba:

        static Bitmap LoadImage()
        {
            return (Bitmap)Bitmap.FromFile( @"e:\Tests\d_bigImage.bmp" ); //here is large image 9222x9222 pixels and 95.96 dpi resolutions
        }
    
        static void TestBigImagePartDrawing()
        {
            using( var absentRectangleImage = LoadImage() )
            {
                using( var currentTile = new Bitmap( 256, 256 ) )
                {
                    currentTile.SetResolution(absentRectangleImage.HorizontalResolution, absentRectangleImage.VerticalResolution);
    
                    using( var currentTileGraphics = Graphics.FromImage( currentTile ) )
                    {
                        currentTileGraphics.Clear( Color.Black );
                        var absentRectangleArea = new Rectangle( 3, 8963, 256, 256 );
                        currentTileGraphics.DrawImage( absentRectangleImage, 0, 0, absentRectangleArea, GraphicsUnit.Pixel );
                    }
    
                    currentTile.Save(@"e:\Tests\Tile.bmp");
                }
            }
        }
  5. 5

    Es muy fácil:

    • Crear un nuevo Bitmap objeto con la recortada tamaño.
    • Uso Graphics.FromImage para crear un Graphics objeto para el nuevo mapa de bits.
    • Utilizar el DrawImage método para dibujar la imagen en el mapa de bits con un negativo de X y la coordenada y.
  6. 4

    He aquí un ejemplo simple en el recorte de una imagen

    public Image Crop(string img, int width, int height, int x, int y)
    {
        try
        {
            Image image = Image.FromFile(img);
            Bitmap bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
            bmp.SetResolution(80, 60);
    
            Graphics gfx = Graphics.FromImage(bmp);
            gfx.SmoothingMode = SmoothingMode.AntiAlias;
            gfx.InterpolationMode = InterpolationMode.HighQualityBicubic;
            gfx.PixelOffsetMode = PixelOffsetMode.HighQuality;
            gfx.DrawImage(image, new Rectangle(0, 0, width, height), x, y, width, height, GraphicsUnit.Pixel);
            //Dispose to free up resources
            image.Dispose();
            bmp.Dispose();
            gfx.Dispose();
    
            return bmp;
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
            return null;
        }            
    }
    • Él es el único que menciona la resolución, todos los métodos anteriores, se producirá un error si la imagen de origen no cuenta con resolución estándar.
    • el uso de bmp.SetResolution(la imagen .HorizontalResolution, de la imagen .VerticalResolution); para solucionar problema de resolución.
    • En esta excepción se fuga de la imagen, bmp y gfx objetos. ¿Por qué no para envolver aquellos en el uso de declaraciones?
  7. 1

    Hay un C# contenedor para que el que es de código abierto, alojado en Codeplex llamado Web De Recorte De Imágenes

    Registrar el control

    <%@ Register Assembly="CS.Web.UI.CropImage" Namespace="CS.Web.UI" TagPrefix="cs" %>

    Cambio de tamaño de

    <asp:Image ID="Image1" runat="server" ImageUrl="images/328.jpg" />
    <cs:CropImage ID="wci1" runat="server" Image="Image1" 
         X="10" Y="10" X2="50" Y2="50" />

    Recorte en el código detrás de – la Llamada de los Cultivos método cuando el botón pulsado por ejemplo;

    wci1.Crop(Server.MapPath("images/sample1.jpg"));

  8. 1

    Yo estaba buscando una fácil y RÁPIDA con la función de no más de biblioteca para hacer el trabajo. Traté de Nicks solución, pero necesitaba 29,4 sec para «extraer» 1195 imágenes de un atlas de archivo. Más tarde lo he conseguido de esta manera y necesita 2,43 sec para hacer el mismo trabajo. Tal vez esto va a ser útil.

    //content of the Texture class
    public class Texture
    {
        //name of the texture
        public string name { get; set; }
        //x position of the texture in the atlas image
        public int x { get; set; }
        //y position of the texture in the atlas image
        public int y { get; set; }
        //width of the texture in the atlas image
        public int width { get; set; }
        //height of the texture in the atlas image
        public int height { get; set; }
    }
    
    Bitmap atlasImage = new Bitmap(@"C:\somepicture.png");
    PixelFormat pixelFormat = atlasImage.PixelFormat;
    
    foreach (Texture t in textureList)
    {
         try
         {
               CroppedImage = new Bitmap(t.width, t.height, pixelFormat);
               //copy pixels over to avoid antialiasing or any other side effects of drawing
               //the subimages to the output image using Graphics
               for (int x = 0; x < t.width; x++)
                   for (int y = 0; y < t.height; y++)
                       CroppedImage.SetPixel(x, y, atlasImage.GetPixel(t.x + x, t.y + y));
               CroppedImage.Save(Path.Combine(workingFolder, t.name + ".png"), ImageFormat.Png);
         }
         catch (Exception ex)
         {
              //handle the exception
         }
    }
  9. 0

    Suponiendo que significa que usted desea tomar un archivo de imagen (JPEG, BMP, TIFF, etc) y de los cultivos que, a continuación, guárdelo como un pequeño archivo de imagen, yo sugiero utilizar una herramienta de terceros que tiene una .NET API. Aquí están algunos de los más populares que me gusta:

    LeadTools

    Accusoft Pegasus
    La nieve de Imagen SDK

  10. 0

    El recorte de una imagen es muy fácil en C#. Sin embargo, haciendo las cosas, ¿cómo vas a gestionar el recorte de la imagen será un poco más difícil.

    Muestra a continuación es la manera de cómo recortar una imagen en C#.

    var filename = @"c:\personal\images\horizon.png";
    var img = Image.FromFile(filename);
    var rect = new Rectangle(new Point(0, 0), img.Size);
    var cloned = new Bitmap(img).Clone(rect, img.PixelFormat);
    var bitmap = new Bitmap(cloned, new Size(50, 50));
    cloned.Dispose();
  11. 0

    Sólo este ejemplo de trabajo sin problema:

    var crop = new Rectangle(0, y, bitmap.Width, h);
    var bmp = new Bitmap(bitmap.Width, h);
    var tempfile = Application.StartupPath+"\"+"TEMP"+"\"+Path.GetRandomFileName();
    
    
    using (var gr = Graphics.FromImage(bmp))
    {
        try
        {
            var dest = new Rectangle(0, 0, bitmap.Width, h);
            gr.DrawImage(image,dest , crop, GraphicsUnit.Point);
            bmp.Save(tempfile,ImageFormat.Jpeg);
            bmp.Dispose();
        }
        catch (Exception)
        {
    
    
        }
    
    }
  12. 0

    Esta es otra manera. En mi caso tengo:

    • 2 numérico updown controles (llamado LeftMargin y TopMargin)
    • 1 cuadro de Imagen (pictureBox1)
    • 1 botón que he llamado a generar
    • 1 imagen en C:\imagenes\myImage.gif

    Dentro del botón tengo este código:

    Image myImage = Image.FromFile(@"C:\imagenes\myImage.gif");
    Bitmap croppedBitmap = new Bitmap(myImage);
    croppedBitmap = croppedBitmap.Clone(
                new Rectangle(
                    (int)LeftMargin.Value, (int)TopMargin.Value,
                    myImage.Width - (int)LeftMargin.Value,
                    myImage.Height - (int)TopMargin.Value),
                System.Drawing.Imaging.PixelFormat.DontCare);
    pictureBox1.Image = croppedBitmap;

    He probado en 2012 de Visual studio con C#. He encontrado esta solución de este página

  13. 0

    aquí es demo en github

    https://github.com/SystematixIndore/Crop-SaveImageInCSharp

    <%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebForm1.aspx.cs" Inherits="WebApplication1.WebForm1" %>
    <!DOCTYPE html>
    <html xmlns="http://www.w3.org/1999/xhtml">
    <head runat="server">
    <title></title>
    <link href="css/jquery.Jcrop.css" rel="stylesheet" type="text/css" />
    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js"></script>
    <script type="text/javascript" src="js/jquery.Jcrop.js"></script>
    </head>
    <body>
    <form id="form2" runat="server">
    <div>
    <asp:Panel ID="pnlUpload" runat="server">
    <asp:FileUpload ID="Upload" runat="server" />
    <br />
    <asp:Button ID="btnUpload" runat="server" OnClick="btnUpload_Click" Text="Upload" />
    <asp:Label ID="lblError" runat="server" Visible="false" />
    </asp:Panel>
    <asp:Panel ID="pnlCrop" runat="server" Visible="false">
    <asp:Image ID="imgCrop" runat="server" />
    <br />
    <asp:HiddenField ID="X" runat="server" />
    <asp:HiddenField ID="Y" runat="server" />
    <asp:HiddenField ID="W" runat="server" />
    <asp:HiddenField ID="H" runat="server" />
    <asp:Button ID="btnCrop" runat="server" Text="Crop" OnClick="btnCrop_Click" />
    </asp:Panel>
    <asp:Panel ID="pnlCropped" runat="server" Visible="false">
    <asp:Image ID="imgCropped" runat="server" />
    </asp:Panel>
    </div>
    </form>
    <script type="text/javascript">
    jQuery(document).ready(function() {
    jQuery('#imgCrop').Jcrop({
    onSelect: storeCoords
    });
    });
    function storeCoords(c) {
    jQuery('#X').val(c.x);
    jQuery('#Y').val(c.y);
    jQuery('#W').val(c.w);
    jQuery('#H').val(c.h);
    };
    </script>
    </body>
    </html>

    C# el código de la lógica para la carga y la cosecha.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Web.UI;
    using System.Web.UI.WebControls;
    using System.IO;
    using SD = System.Drawing;
    using System.Drawing.Imaging;
    using System.Drawing.Drawing2D;
    namespace WebApplication1
    {
    public partial class WebForm1 : System.Web.UI.Page
    {
    String path = HttpContext.Current.Request.PhysicalApplicationPath + "images\\";
    protected void Page_Load(object sender, EventArgs e)
    {
    }
    protected void btnUpload_Click(object sender, EventArgs e)
    {
    Boolean FileOK = false;
    Boolean FileSaved = false;
    if (Upload.HasFile)
    {
    Session["WorkingImage"] = Upload.FileName;
    String FileExtension = Path.GetExtension(Session["WorkingImage"].ToString()).ToLower();
    String[] allowedExtensions = { ".png", ".jpeg", ".jpg", ".gif" };
    for (int i = 0; i < allowedExtensions.Length; i++)
    {
    if (FileExtension == allowedExtensions[i])
    {
    FileOK = true;
    }
    }
    }
    if (FileOK)
    {
    try
    {
    Upload.PostedFile.SaveAs(path + Session["WorkingImage"]);
    FileSaved = true;
    }
    catch (Exception ex)
    {
    lblError.Text = "File could not be uploaded." + ex.Message.ToString();
    lblError.Visible = true;
    FileSaved = false;
    }
    }
    else
    {
    lblError.Text = "Cannot accept files of this type.";
    lblError.Visible = true;
    }
    if (FileSaved)
    {
    pnlUpload.Visible = false;
    pnlCrop.Visible = true;
    imgCrop.ImageUrl = "images/" + Session["WorkingImage"].ToString();
    }
    }
    protected void btnCrop_Click(object sender, EventArgs e)
    {
    string ImageName = Session["WorkingImage"].ToString();
    int w = Convert.ToInt32(W.Value);
    int h = Convert.ToInt32(H.Value);
    int x = Convert.ToInt32(X.Value);
    int y = Convert.ToInt32(Y.Value);
    byte[] CropImage = Crop(path + ImageName, w, h, x, y);
    using (MemoryStream ms = new MemoryStream(CropImage, 0, CropImage.Length))
    {
    ms.Write(CropImage, 0, CropImage.Length);
    using (SD.Image CroppedImage = SD.Image.FromStream(ms, true))
    {
    string SaveTo = path + "crop" + ImageName;
    CroppedImage.Save(SaveTo, CroppedImage.RawFormat);
    pnlCrop.Visible = false;
    pnlCropped.Visible = true;
    imgCropped.ImageUrl = "images/crop" + ImageName;
    }
    }
    }
    static byte[] Crop(string Img, int Width, int Height, int X, int Y)
    {
    try
    {
    using (SD.Image OriginalImage = SD.Image.FromFile(Img))
    {
    using (SD.Bitmap bmp = new SD.Bitmap(Width, Height))
    {
    bmp.SetResolution(OriginalImage.HorizontalResolution, OriginalImage.VerticalResolution);
    using (SD.Graphics Graphic = SD.Graphics.FromImage(bmp))
    {
    Graphic.SmoothingMode = SmoothingMode.AntiAlias;
    Graphic.InterpolationMode = InterpolationMode.HighQualityBicubic;
    Graphic.PixelOffsetMode = PixelOffsetMode.HighQuality;
    Graphic.DrawImage(OriginalImage, new SD.Rectangle(0, 0, Width, Height), X, Y, Width, Height, SD.GraphicsUnit.Pixel);
    MemoryStream ms = new MemoryStream();
    bmp.Save(ms, OriginalImage.RawFormat);
    return ms.GetBuffer();
    }
    }
    }
    }
    catch (Exception Ex)
    {
    throw (Ex);
    }
    }
    }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here