Dibujar imágenes rasterizadas y vectoriales

Ya sea que esté creando un sitio web, una aplicación de escritorio o una aplicación móvil, la capacidad de manipular y dibujar imágenes es un aspecto crucial al procesar y editar imágenes. Para brindar a los desarrolladores funciones de dibujo avanzadas pero fáciles de implementar, presentamos Aspose.Imaging.Drawing, una poderosa API diseñada para aplicaciones C# .NET, que ofrece una variedad de funciones de dibujo de imágenes.

Biblioteca de dibujos C# .NET

Aspose.Imaging.Drawing es una API robusta que le permite procesar imágenes rasterizadas y vectoriales con técnicas avanzadas de procesamiento de imágenes. Con acceso a bytes nativo, la API garantiza una alta velocidad de procesamiento al crear o manipular imágenes. Con la API, puede dibujar objetos con manipulación de píxeles y ruta de gráficos y convertir imágenes de un formato a otro. Aspose.Imaging.Drawing utiliza Aspose.Drawing como motor gráfico predeterminado, que es una biblioteca de gráficos 2D multiplataforma que ofrece un conjunto completo de funciones para dibujar texto, geometrías e imágenes sin dependencias externas.

Puede descargar e instalar Aspose.Imaging.Drawing desde NuGet.

PM> NuGet\Install-Package Aspose.Imaging.Drawing

Ahora echemos un vistazo a algunas características destacadas de esta API de dibujo .NET y su uso con la ayuda del código fuente.

Creación de gráficos utilizando la biblioteca de dibujos .NET

Aspose.Imaging.Drawing te permite crear imágenes dibujando diferentes objetos como círculos, líneas, triángulos, cuadrados y elipses. No solo las imágenes rasterizadas, sino que también puedes generar imágenes vectoriales utilizando la API. Echemos un vistazo a cómo dibujar imágenes rasterizadas y vectoriales en C# usando esta API de dibujo .NET.

Dibujar imagen rasterizada

A continuación se detallan los pasos para dibujar una imagen rasterizada utilizando la API Aspose.Imaging.Drawing.

  • Primero, cree una imagen del formato deseado usando el método Image.Create().
  • Luego, cree un objeto de la clase Gráficos e inicialícelo con la Imagen que hemos creado anteriormente.
  • Borre la superficie de la imagen usando el método Graphics.Clear.
  • Cree un nuevo bolígrafo e inicialícelo con el color deseado.
  • Dibuja una elipse (o cualquier otro objeto gráfico) usando el método Graphics.DrawEllipse().
  • Dibuja un polígono usando el método Graphics.FillPolygon().
  • Finalmente, guarde la imagen usando el método Image.Save().

El siguiente fragmento de código muestra cómo dibujar una imagen en C#.

string outputFolder = @"Output\";

// Cree una instancia de BmpOptions y establezca sus diversas propiedades
BmpOptions imageOptions = new BmpOptions();
imageOptions.BitsPerPixel = 24;

// Cree una instancia de FileCreateSource y asígnela a la propiedad Fuente 
imageOptions.Source = new FileCreateSource(outputFolder + "result.bmp", false);

using (var image = Image.Create(imageOptions, 500, 500))
{
    var graphics = new Graphics(image);

    // Borre la superficie de la imagen con color blanco y cree e inicialice un objeto Pluma con color azul
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Blue);

    // Dibuje Elipse definiendo el rectángulo delimitador de ancho 150 y alto 100. También dibuje un polígono usando LinearGradientBrush.
    graphics.DrawEllipse(pen, new Rectangle(10, 10, 150, 100));

    using (var linearGradientBrush = new LinearGradientBrush(image.Bounds, Color.Red, Color.White, 45f))
    {
        graphics.FillPolygon(linearGradientBrush, new[] { new Point(200, 200), new Point(400, 200), new Point(250, 350) });
    }

    // Guardar imagen
    image.Save();
}

Dibujar imagen vectorial

De manera similar a las imágenes rasterizadas, puede dibujar gráficos vectoriales, como SVG, en unos sencillos pasos. Creemos una imagen vectorial usando nuestra biblioteca de dibujo C#.

  • Primero, cree un objeto MemoryStream.
  • Luego, cargue una imagen SVG.
  • Rasterice SVG a PNG y escriba el resultado en una secuencia.
  • Cargue una imagen PNG de la secuencia para seguir dibujando.
  • Dibuje una imagen PNG en una imagen SVG existente.
  • Finalmente, guarde los resultados.

El siguiente fragmento de código muestra cómo dibujar una imagen vectorial en C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (MemoryStream drawnImageStream = new MemoryStream())
{
    // Primero, rasterice SVG a Png y escriba el resultado en una secuencia.
    using (SvgImage svgImage = (SvgImage)Image.Load(templatesFolder + "template.svg"))
    {
        SvgRasterizationOptions rasterizationOptions = new SvgRasterizationOptions();
        rasterizationOptions.PageSize = svgImage.Size;

        PngOptions saveOptions = new PngOptions();
        saveOptions.VectorRasterizationOptions = rasterizationOptions;

        svgImage.Save(drawnImageStream, saveOptions);

        // Ahora cargue una imagen Png de la secuencia para seguir dibujando.
        drawnImageStream.Seek(0, System.IO.SeekOrigin.Begin);
        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))
        {
            // Basándose en la imagen SVG existente.
            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Reduce la imagen dibujada completa 2 veces y dibújala en el centro de la superficie de dibujo.
            int width = imageToDraw.Width / 2;
            int height = imageToDraw.Height / 2;
            Point origin = new Point((svgImage.Width - width) / 2, (svgImage.Height - height) / 2);
            Size size = new Size(width, height);

            graphics.DrawImage(imageToDraw, origin, size);

            // Guardar la imagen del resultado
            using (SvgImage resultImage = graphics.EndRecording())
            {
                resultImage.Save(outputFolder + "vector_image.svg");
            }
        }
    }
}

Aplicar enmascaramiento a imágenes

El enmascaramiento en la edición de imágenes se refiere a la técnica de ocultar o revelar selectivamente ciertas partes de una imagen. Implica crear una máscara, que es esencialmente una imagen en escala de grises que define la transparencia u opacidad de cada píxel de la imagen original. El enmascaramiento de imágenes se practica ampliamente para el reconocimiento y el diagnóstico.

Aspose.Image.Drawing proporciona dos métodos para aplicar enmascaramiento de imágenes:

  • Enmascaramiento manual: utiliza un conjunto de ROI como máscara. Las ROI de cada segmento se utilizan para definir la máscara. Necesita información adicional del usuario.
  • Enmascaramiento automático: no requiere muchos datos de entrada por parte del usuario, pero puede no ser tan preciso.

Veamos ahora cómo aplicar enmascaramiento manual y automático en imágenes en código C#.

Enmascaramiento de imagen manual

El siguiente fragmento de código muestra cómo aplicar enmascaramiento manual en una imagen en C#.

string outputFolder = @"Output\";

// Archivo fuente
string sourceFileName = outputFolder + "couple.png";

// Crear ruta de gráficos
GraphicsPath manualMask = new GraphicsPath();

// Agregar formas
Figure firstFigure = new Figure();
firstFigure.AddShape(new EllipseShape(new RectangleF(100, 30, 40, 40)));
firstFigure.AddShape(new RectangleShape(new RectangleF(10, 200, 50, 30)));

// Añadir figura
manualMask.AddFigure(firstFigure);

GraphicsPath subPath = new GraphicsPath();
Figure secondFigure = new Figure();
secondFigure.AddShape(
    new PolygonShape(
     new PointF[]
     {
        new PointF(310, 100), new PointF(350, 200), new PointF(250, 200)

     }, true));

secondFigure.AddShape(new PieShape(new RectangleF(10, 10, 80, 80), 30, 120));
subPath.AddFigure(secondFigure);
manualMask.AddPath(subPath);

// Aplicar enmascaramiento
using (RasterImage image = (RasterImage)Image.Load(sourceFileName))
{
    MaskingOptions maskingOptions = new MaskingOptions()
    {
        Method = SegmentationMethod.Manual,
        Args = new ManualMaskingArgs
        {
            Mask = manualMask
        },
        Decompose = false,
        ExportOptions =
      new PngOptions()
      {
          ColorType = PngColorType.TruecolorWithAlpha,
          Source = new StreamSource(new MemoryStream())
      },
    };
    MaskingResult results = new ImageMasking(image).Decompose(maskingOptions);
    // Guardando el resultado final del enmascaramiento.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "manual_masking.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Enmascaramiento automático de imágenes

El siguiente fragmento de código aplica el enmascaramiento automático en una imagen utilizando la API de dibujo .NET.

string outputFolder = @"Output\";

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(outputFolder + "couple.jpg"))
{
    // Para utilizar Graph Cut con trazos calculados automáticamente, se utiliza AutoMaskingGraphCutOptions.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        // Indicando que se debe realizar un nuevo cálculo de los trazos predeterminados durante la descomposición de la imagen.
        CalculateDefaultStrokes = true,
        
        // Configuración del radio de desvanecimiento posterior al proceso según el tamaño de la imagen.
        FeatheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(outputFolder + "auto_masking.png")
            },
        BackgroundReplacementColor = Color.Transparent
    };

    results = new ImageMasking(image).Decompose(options);

    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "auto_masking_2.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Aplicar filtros a las imágenes

La aplicación de filtros a las imágenes tiene varios propósitos y la gente los usa por diversas razones, tanto prácticas como artísticas. Los usos más comunes de los filtros de imagen incluyen corrección de color, mejora de la calidad de la imagen, aplicación de efectos especiales, reducción de ruido, etc. Aspose.Imaging.Drawing admite varios tipos de filtros que puede aplicar a las imágenes, como mediana, movimiento weiner, gauss weiner, etc.

Para una demostración, eche un vistazo al siguiente código que aplica el filtro mediano a una imagen usando Aspose.Imaging.Drawing.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Cargar la imagen ruidosa 
using (Image image = Image.Load(templatesFolder + "template.gif"))
{
    // Convertir la imagen en RasterImage
    RasterImage rasterImage = image as RasterImage;
    if (rasterImage == null)
    {
        return;
    }

    // Cree una instancia de la clase MedianFilterOptions y establezca el tamaño, aplique el filtro MedianFilterOptions al objeto RasterImage y guarde la imagen resultante.
    MedianFilterOptions options = new MedianFilterOptions(4);
    rasterImage.Filter(image.Bounds, options);

    // Guardar imagen
    image.Save(outputFolder + "median_filter.gif");
}

Recortar, rotar y cambiar el tamaño de imágenes

Recortar, rotar y cambiar el tamaño de las imágenes se consideran características esenciales de las aplicaciones de edición de imágenes. Son las operaciones de procesamiento de imágenes más comunes que se utilizan para manipular imágenes digitales. Echemos un vistazo a cómo recortar, rotar y cambiar el tamaño de imágenes usando la API Aspose.Imaging.Drawing.

Recortar una imagen

Para recortar una imagen, debe proporcionar los valores de desplazamiento para los cuatro lados de la imagen. Según estos valores, los límites de la imagen se desplazan hacia el centro de la imagen. El siguiente fragmento de código C# recorta una imagen según los valores de desplazamiento proporcionados.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Cargue una imagen existente en una instancia de la clase RasterImage
using (RasterImage rasterImage = (RasterImage)Image.Load(templatesFolder + "template.jpg"))
{
    // Antes de recortar, la imagen debe almacenarse en caché para un mejor rendimiento.
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Definir valores de desplazamiento para los cuatro lados
    int leftShift = 10;
    int rightShift = 10;
    int topShift = 10;
    int bottomShift = 10;

    // Según los valores de desplazamiento, aplique el recorte en la imagen. El método de recorte desplazará los límites de la imagen hacia el centro de la imagen y guardará los resultados en el disco.
    rasterImage.Crop(leftShift, rightShift, topShift, bottomShift);

    // Guardar imagen recortada
    rasterImage.Save(outputFolder + "cropped_image.jpg");
}

Girar una imagen

Para rotar una imagen, Aspose.Imaging.Drawing proporciona el método RotateFlip, que no solo rota una imagen sino que también la voltea (si es necesario). Puede elegir la opción de rotación y volteo deseada en la enumeración RotateFlipType. El siguiente fragmento de código muestra cómo rotar una imagen pero no voltearla en C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Cargando y rotando imagen
using (var image = Image.Load(templatesFolder + "template.jpg"))
{
    // Girar imagen
    image.RotateFlip(RotateFlipType.Rotate270FlipNone);

    // Guardar imagen
    image.Save(outputFolder + "rotated_image.jpg");
}

Cambiar el tamaño de una imagen

Cambiar el tamaño de una imagen usando Aspose.Imaging.Drawing es tan simple como un pastel. Simplemente llame al método Resize y pase los nuevos valores de alto y ancho. El siguiente fragmento de código muestra cómo cambiar el tamaño de una imagen en C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (Image image = Image.Load(templatesFolder + "template.jpg"))
{
    // Cambiar el tamaño de la imagen
    image.Resize(300, 300);

    // Guardar imagen
    image.Save(outputFolder + "resized_image.jpg");
}

Convertir imágenes a otros formatos

Para convertir una imagen usando Aspose.Imaging.Drawing API, solo necesita cargar la imagen y guardarla en el formato de salida deseado. El siguiente fragmento de código convierte una imagen JPG a formatos WebP, PSD, PDF y TIFF.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (var img = Aspose.Imaging.Image.Load(templatesFolder + "template.jpg"))
{
    // Guardar en diferentes formatos de imagen.
    img.Save(outputFolder + "output.webp", new Aspose.Imaging.ImageOptions.WebPOptions());
    img.Save(outputFolder + "output.psd ", new Aspose.Imaging.ImageOptions.PsdOptions());
    img.Save(outputFolder + "output.tiff", new Aspose.Imaging.ImageOptions.TiffOptions(TiffExpectedFormat.Default));

    // Guardar como pdf
    PdfOptions exportOptions = new PdfOptions();
    exportOptions.PdfDocumentInfo = new Aspose.Imaging.FileFormats.Pdf.PdfDocumentInfo();
    img.Save(outputFolder + "output.pdf", exportOptions);
}

Obtenga una licencia API gratuita

Si desea evaluar la API Aspose.Imaging.Drawing, puede obtener una licencia temporal gratuita que le permite utilizar la API en su máxima capacidad sin limitaciones.

Conclusión

En el ámbito del procesamiento de imágenes y gráficos, la API Aspose.Imaging.Drawing se destaca como una herramienta versátil y poderosa para los desarrolladores de C# .NET. Ya sea que esté buscando mejorar elementos visuales, corregir distorsiones de imágenes o convertir imágenes entre formatos, esta API proporciona un conjunto completo de funciones. Con Aspose.Imaging.Drawing, la manipulación de imágenes está al alcance de su mano, permitiéndole crear gráficos atractivos y visualmente impresionantes mediante programación.

Háganos saber sus comentarios o consultas en nuestro foro.