Desenhar imagens raster e vetoriais

Esteja você construindo um site, um aplicativo de desktop ou um aplicativo móvel, a capacidade de manipular e desenhar imagens é um aspecto crucial ao processar e editar imagens. Para capacitar os desenvolvedores com recursos de desenho avançados, mas fáceis de implementar, apresentamos Aspose.Imaging.Drawing, uma API poderosa projetada para aplicativos C# .NET, que oferece uma variedade de recursos de desenho de imagens.

Biblioteca de desenhos C# .NET

Aspose.Imaging.Drawing é uma API robusta que permite processar imagens raster e vetoriais com técnicas avançadas de processamento de imagem. Com acesso nativo a bytes, a API garante alta velocidade de processamento durante a criação ou manipulação de imagens. Usando a API, você pode desenhar objetos com manipulação de pixels e caminhos gráficos e converter imagens de um formato para outro. Aspose.Imaging.Drawing usa Aspose.Drawing como mecanismo gráfico padrão, que é uma biblioteca gráfica 2D multiplataforma que oferece um conjunto completo de recursos para desenhar texto, geometrias e imagens sem quaisquer dependências externas.

Você pode baixar e instalar o Aspose.Imaging.Drawing em NuGet.

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

Vamos agora dar uma olhada em alguns recursos importantes desta API de desenho .NET e seu uso com a ajuda do código-fonte.

Criando gráficos usando a biblioteca de desenhos .NET

Aspose.Imaging.Drawing permite criar imagens desenhando diferentes objetos, como círculos, linhas, triângulos, quadrados e elipses. Não apenas as imagens raster, mas você pode gerar imagens vetoriais usando a API. Vamos dar uma olhada em como desenhar imagens raster e vetoriais em C# usando esta API de desenho .NET.

Desenhar imagem raster

Abaixo estão as etapas para desenhar uma imagem raster usando a API Aspose.Imaging.Drawing.

  • Primeiro, crie uma imagem no formato desejado usando o método Image.Create().
  • Em seguida, crie um objeto da classe Graphics e inicialize-o com a Imagem que criamos acima.
  • Limpe a superfície da imagem usando o método Graphics.Clear.
  • Crie uma nova Pen e inicialize-a com a cor desejada.
  • Desenhe uma elipse (ou qualquer outro objeto gráfico) usando o método Graphics.DrawEllipse().
  • Desenhe um polígono usando o método Graphics.FillPolygon().
  • Por fim, salve a imagem usando o método Image.Save().

O trecho de código a seguir mostra como desenhar uma imagem em C#.

string outputFolder = @"Output\";

// Crie uma instância de BmpOptions e defina suas diversas propriedades
BmpOptions imageOptions = new BmpOptions();
imageOptions.BitsPerPixel = 24;

// Crie uma instância de FileCreateSource e atribua-a à propriedade Source 
imageOptions.Source = new FileCreateSource(outputFolder + "result.bmp", false);

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

    // Limpe a superfície da imagem com a cor branca e crie e inicialize um objeto Pen com a cor azul
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Blue);

    // Desenhe Ellipse definindo o retângulo delimitador de largura 150 e altura 100 e também Desenhe um 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) });
    }

    // Salvar imagem
    image.Save();
}

Desenhar imagem vetorial

Semelhante às imagens raster, você pode desenhar gráficos vetoriais, como SVG, em algumas etapas simples. Vamos criar uma imagem vetorial usando nossa biblioteca de desenho C#.

  • Primeiro, crie um objeto MemoryStream.
  • Em seguida, carregue uma imagem SVG.
  • Rasterize SVG para PNG e grave o resultado em um stream.
  • Carregue uma imagem PNG do fluxo para desenho adicional.
  • Desenhe uma imagem PNG em uma imagem SVG existente.
  • Finalmente, salve os resultados.

O trecho de código a seguir mostra como desenhar uma imagem vetorial em C#.

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

using (MemoryStream drawnImageStream = new MemoryStream())
{
    // Primeiro, rasterize Svg para Png e grave o resultado em um stream.
    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);

        // Agora carregue uma imagem PNG do stream para desenho adicional.
        drawnImageStream.Seek(0, System.IO.SeekOrigin.Begin);
        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))
        {
            // Baseando-se na imagem Svg existente.
            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Reduza toda a imagem desenhada 2 vezes e desenhe-a no centro da superfície de desenho.
            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);

            // Salve a imagem do resultado
            using (SvgImage resultImage = graphics.EndRecording())
            {
                resultImage.Save(outputFolder + "vector_image.svg");
            }
        }
    }
}

Aplicar máscara às imagens

O mascaramento na edição de imagens refere-se à técnica de ocultar ou revelar seletivamente certas partes de uma imagem. Envolve a criação de uma máscara, que é essencialmente uma imagem em tons de cinza que define a transparência ou opacidade de cada pixel da imagem original. O mascaramento de imagens é amplamente praticado para reconhecimento e diagnóstico.

Aspose.Image.Drawing fornece dois métodos de aplicação de mascaramento de imagem:

  • Mascaramento manual - usa um conjunto de ROIs como máscara. Os ROIs de cada fatia são usados para definir a máscara. Ele precisa de entrada adicional do usuário.
  • Mascaramento automático - Não requer muitos dados de entrada do usuário, mas pode não ser tão preciso.

Vamos agora ver como aplicar mascaramento manual e automático em imagens em código C#.

Mascaramento manual de imagem

O trecho de código a seguir mostra como aplicar o mascaramento manual em uma imagem em C#.

string outputFolder = @"Output\";

// Arquivo fonte
string sourceFileName = outputFolder + "couple.png";

// Criar caminho gráfico
GraphicsPath manualMask = new GraphicsPath();

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

// Adicionar 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 máscara
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);
    // Salvando o resultado final do mascaramento.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "manual_masking.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Mascaramento automático de imagem

O trecho de código abaixo aplica o mascaramento automático em uma imagem usando a API de desenho .NET.

string outputFolder = @"Output\";

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(outputFolder + "couple.jpg"))
{
    // Para usar Graph Cut com traços calculados automaticamente, AutoMaskingGraphCutOptions é usado.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        // Indicando que um novo cálculo dos traços padrão deverá ser realizado durante a decomposição da imagem.
        CalculateDefaultStrokes = true,
        
        // Definir o raio de enevoamento pós-processamento com base no tamanho da imagem.
        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 às imagens

A aplicação de filtros em imagens tem vários propósitos e as pessoas os usam por diversos motivos, tanto práticos quanto artísticos. Os usos mais comuns de filtros de imagem incluem correção de cores, aprimoramento da qualidade da imagem, aplicação de efeitos especiais, redução de ruído e assim por diante. Aspose.Imaging.Drawing suporta vários tipos de filtros que você pode aplicar às imagens, como mediana, motion weiner, gauss weiner, etc.

Para demonstração, dê uma olhada no código a seguir que aplica o filtro mediano a uma imagem usando Aspose.Imaging.Drawing.

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

// Carregue a imagem barulhenta 
using (Image image = Image.Load(templatesFolder + "template.gif"))
{
    // Transforme a imagem em RasterImage
    RasterImage rasterImage = image as RasterImage;
    if (rasterImage == null)
    {
        return;
    }

    // Crie uma instância da classe MedianFilterOptions e defina o tamanho, aplique o filtro MedianFilterOptions ao objeto RasterImage e salve a imagem resultante
    MedianFilterOptions options = new MedianFilterOptions(4);
    rasterImage.Filter(image.Bounds, options);

    // Salvar imagem
    image.Save(outputFolder + "median_filter.gif");
}

Cortar, girar e redimensionar imagens

Cortar, girar e redimensionar imagens são considerados recursos essenciais dos aplicativos de edição de imagens. São as operações de processamento de imagem mais comuns usadas para manipular imagens digitais. Vamos dar uma olhada em como cortar, girar e redimensionar imagens usando a API Aspose.Imaging.Drawing.

Cortar uma imagem

Para cortar uma imagem, você precisa fornecer os valores de deslocamento para todos os quatro lados da imagem. Com base nesses valores, os limites da imagem são deslocados em direção ao centro da imagem. O trecho de código C# a seguir recorta uma imagem com base nos valores de deslocamento fornecidos.

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

// Carregar uma imagem existente em uma instância da classe RasterImage
using (RasterImage rasterImage = (RasterImage)Image.Load(templatesFolder + "template.jpg"))
{
    // Antes de cortar, a imagem deve ser armazenada em cache para melhor desempenho
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Defina valores de deslocamento para todos os quatro lados
    int leftShift = 10;
    int rightShift = 10;
    int topShift = 10;
    int bottomShift = 10;

    // Com base nos valores de deslocamento, aplique o corte na imagem O método de corte mudará os limites da imagem em direção ao centro da imagem e salvará os resultados no disco
    rasterImage.Crop(leftShift, rightShift, topShift, bottomShift);

    // Salvar imagem recortada
    rasterImage.Save(outputFolder + "cropped_image.jpg");
}

Girar uma imagem

Para girar uma imagem, Aspose.Imaging.Drawing fornece o método RotateFlip, que não apenas gira uma imagem, mas também a vira (se necessário). Você pode escolher a opção desejada de rotação e inversão na enumeração RotateFlipType. O trecho de código a seguir mostra como girar uma imagem, mas não invertê-la em C#.

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

// Carregando e girando imagem
using (var image = Image.Load(templatesFolder + "template.jpg"))
{
    // Girar imagem
    image.RotateFlip(RotateFlipType.Rotate270FlipNone);

    // Salvar imagem
    image.Save(outputFolder + "rotated_image.jpg");
}

Redimensionar uma imagem

Redimensionar uma imagem usando Aspose.Imaging.Drawing é tão simples quanto uma torta. Basta chamar o método Resize e passar os novos valores de altura e largura. O trecho de código a seguir mostra como redimensionar uma imagem em C#.

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

using (Image image = Image.Load(templatesFolder + "template.jpg"))
{
    // Redimensionar imagem
    image.Resize(300, 300);

    // Salvar imagem
    image.Save(outputFolder + "resized_image.jpg");
}

Converter imagens para outros formatos

Para converter uma imagem usando a API Aspose.Imaging.Drawing, você só precisa carregar a imagem e salvá-la no formato de saída desejado. O trecho de código a seguir converte uma imagem JPG nos formatos WebP, PSD, PDF e TIFF.

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

using (var img = Aspose.Imaging.Image.Load(templatesFolder + "template.jpg"))
{
    // Salve em diferentes formatos de imagem
    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));

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

Obtenha uma licença API gratuita

Se quiser avaliar a API Aspose.Imaging.Drawing, você pode obter uma licença temporária gratuita que permite usar a API em sua capacidade total, sem quaisquer limitações.

Conclusão

No domínio de gráficos e processamento de imagens, a API Aspose.Imaging.Drawing se destaca como uma ferramenta versátil e poderosa para desenvolvedores C# .NET. Esteja você procurando aprimorar elementos visuais, corrigir distorções de imagem ou converter imagens entre formatos, esta API fornece um conjunto abrangente de recursos. Com Aspose.Imaging.Drawing, a manipulação de imagens está ao seu alcance, permitindo que você crie gráficos atraentes e visualmente impressionantes de forma programática.

Deixe-nos saber seus comentários ou dúvidas em nosso fórum.