Criar layouts mosaicos manualmente é um processo tedioso e errado, especialmente quando se trata de dezenas ou centenas de imagens. Esta tarefa torna-se ainda mais desafiante se você precisa manter a consistência em vários projetos ou campanhas. Com o surgimento de ferramentas de automação como Aspose.Imaging para .NET, os desenvolvedores agora podem criar perfeitos, repetíveis mozaicos de imagem sem esforço.

Neste post do blog, vamos explorar como automatizar o processo de fusão de múltiplas imagens em um layout de rede usando Aspose.Imaging para .NET. Nós vamos cobrir tudo desde a configuração do seu ambiente e a organização de imagens de origem para reorganizar e organizar-as num formato da rede.

Pré-requisitos

Antes de mergulhar no código, certifique-se de que você tem os seguintes requisitos estabelecidos:

  • Visual Studio 2019 ou posterior
  • .NET 6.0 ou posterior (ou .Net Framework 4.6.2+)
  • Aspose.Imaging para .NET de NuGet

Exemplo de código: Automatização da imagem Mosaic Layouts C#

using System;
using System.Collections.Generic;
using System.Drawing;
using Aspose.Imaging;
using Aspose.Imaging.FileFormats;

public class ImageMosaicGenerator
{
    public static void Main(string[] args)
    {
        // Initialize metered license
        Metered metered = new Metered();
        metered.SetMeteredKey("your-public-key", "your-private-key");

        string inputFolder = @"path\to\input\images";
        int rows = 5;
        int columns = 4;

        List<string> imagePaths = GetImageFilePaths(inputFolder);
        
        // Calculate output canvas dimensions
        int totalWidth = columns * 200; // Assuming each image is resized to 200x200 pixels
        int totalHeight = rows * 200;
        
        using (Bitmap compositeImage = new Bitmap(totalWidth, totalHeight))
        {
            Graphics graphics = Graphics.FromImage(compositeImage);
            
            for (int i = 0; i < imagePaths.Count; i++)
            {
                string imagePath = imagePaths[i];
                
                // Load and resize images
                Image image = Image.Load(imagePath);
                int newWidth = 200;
                int newHeight = 200;

                if (image.VerticalResolution != 96 || image.HorizontalResolution != 96)
                {
                    image.ResizeFullFrame(newWidth, newHeight, ResizeType.Bicubic);
                }
                
                // Calculate position in grid
                int xPosition = (i % columns) * newWidth;
                int yPosition = (i / columns) * newHeight;

                graphics.DrawImage(image, xPosition, yPosition);
            }

            // Save the composite image
            string outputFilePath = @"path\to\output\mosaic.jpg";
            compositeImage.Save(outputFilePath);

            Console.WriteLine($"Mosaic layout saved to {outputFilePath}");
        }
    }

    private static List<string> GetImageFilePaths(string folderPath)
    {
        // Implement logic to get all image file paths from the specified folder
        return new List<string>();
    }
}

Entendendo o Código

Vamos descartar as partes-chave desta implementação:

Passo 1: A configuração inicial

Primeiro, iniciamos a licença medida e carregamos os arquivos de entrada:

// Initialize metered license
Metered metered = new Metered();
metered.SetMeteredKey("your-public-key", "your-private-key");

string inputFolder = @"path\to\input\images";
int rows = 5;
int columns = 4;

List<string> imagePaths = GetImageFilePaths(inputFolder);

Esta seção coloca as licenças necessárias e carrega todas as imagens de uma pasta especificada para uma lista.

Passo 2: Calcular as dimensões de canvas de saída

A seguir, calculamos as dimensões da canva de saída com base no número de linhas e colunas:

int totalWidth = columns * 200; // Assuming each image is resized to 200x200 pixels
int totalHeight = rows * 200;

Aqui, determinamos a largura e altura da imagem composta com base nas dimensões da rede.

Passo 3: Carregar e resignar imagens

Agora, carregamos cada imagem da lista e reincorporamos para se encaixar dentro da rede:

using (Bitmap compositeImage = new Bitmap(totalWidth, totalHeight))
{
    Graphics graphics = Graphics.FromImage(compositeImage);
    
    for (int i = 0; i < imagePaths.Count; i++)
    {
        string imagePath = imagePaths[i];
        
        // Load and resize images
        Image image = Image.Load(imagePath);
        int newWidth = 200;
        int newHeight = 200;

        if (image.VerticalResolution != 96 || image.HorizontalResolution != 96)
        {
            image.ResizeFullFrame(newWidth, newHeight, ResizeType.Bicubic);
        }
    }
}

Este snippet carrega cada imagem e o resisa a um tamanho uniforme antes de colocá-lo na rede.

Passo 4: Arranjar imagens na rede

Em seguida, calculamos a posição de cada imagem dentro da rede e desenhamos-a usando Graphics.DrawImage:

// Calculate position in grid
int xPosition = (i % columns) * newWidth;
int yPosition = (i / columns) * newHeight;

graphics.DrawImage(image, xPosition, yPosition);

Esta parte garante que cada imagem é colocada corretamente dentro da imagem composta com base no seu índice.

Passo 5: Salvar a imagem compacta

Finalmente, salvo a imagem composta para um caminho de saída especificado:

// Save the composite image
string outputFilePath = @"path\to\output\mosaic.jpg";
compositeImage.Save(outputFilePath);

Console.WriteLine($"Mosaic layout saved to {outputFilePath}");

Este snippet salva a imagem mosaica final em um arquivo.

Conclusão

Neste post de blog, exploramos como automatizar o processo de criação de mosaicos de imagem usando Aspose.Imaging para .NET. Ao seguir os passos descritos neste guia, você pode facilmente criar layouts de rede consistentes e visualmente atraentes programadamente.

Sinta-se livre para experimentar com diferentes configurações e melhorias para adaptar a solução às suas necessidades específicas!

More in this category