Créer des layouts mosaïques manuellement est un processus aveugle et sans erreur, en particulier lorsqu’il s’agit de dizaines ou de centaines d’images. Cette tâche devient encore plus difficile si vous avez besoin de maintenir la cohérence sur plusieurs projets ou campagnes. Avec l’arrivée des outils d’automatisation tels que Aspose.Imaging pour .NET, les développeurs peuvent maintenant créer parfaits, récurrents mozaics image sans effort.

Dans cet article sur le blog, nous explorerons comment automatiser le processus de fusion de plusieurs images dans un layout réseau en utilisant Aspose.Imaging pour .NET. Nous couvrirons tout, de la configuration de votre environnement et de l’organisation des images source à la reprise et l’arrangement en format réseau. À la fin de ce guide, vous aurez une compréhension approfondie de comment utiliser Asposa.Imagination pour créer des mosaïques d’image merveilleux programmablement.

Principaux

Avant de vous plonger dans le code, assurez-vous que vous avez les conditions préalables suivantes:

  • Visual Studio 2019 ou ultérieur
  • .NET 6.0 ou ultérieur (ou .Net Framework 4.6.2+)
  • Aspose.Imaging pour .NET de NuGet

Exemple de code: Automatiser l’image 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>();
    }
}

Comprendre le code

Découvrez les éléments clés de cette mise en œuvre:

Étape 1 : Configuration initiale

Premièrement, nous initialisons la licence mesurée et chargons les fichiers d’entrée:

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

Cette section établit les licences nécessaires et charge toutes les images d’un dossier spécifié dans une liste.

Étape 2 : Calculer les dimensions des canvas de sortie

Ensuite, nous calculons les dimensions des canvas de sortie en fonction du nombre de rangs et de colonnes:

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

Ici, nous déterminons la largeur et la hauteur de l’image composite en fonction des dimensions du réseau.

Étape 3 : Récupérer et télécharger des images

Maintenant, nous téléchargons chaque image de la liste et la réaffichons pour s’adapter à l’intérieur du réseau:

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);
        }
    }
}

Ce snippet charge chaque image et le récite à une taille uniforme avant de le placer dans la grille.

Étape 4 : organiser les images dans le réseau

Nous calculons ensuite la position de chaque image au sein de la grille et le dessinons en utilisant Graphics.DrawImage:

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

graphics.DrawImage(image, xPosition, yPosition);

Cette partie s’assure que chaque image est correctement placée dans l’image composite basée sur son index.

Étape 5 : sauvegarder l’image composite

Enfin, nous enregistrons l’image composite à une voie de sortie spécifiée:

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

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

Ce snippet enregistre l’image mosaïque finale dans un fichier.

Conclusion

Dans cet article sur le blog, nous avons exploré comment automatiser le processus de création de mozaïques d’image en utilisant Aspose.Imaging pour .NET. En suivant les étapes indiquées dans ce guide, vous pouvez facilement créer des layouts de réseau cohérents et visuellement attrayants programmatiquement.

Sentez-vous libre d’expérimenter avec différentes configurations et améliorations pour adapter la solution à vos besoins spécifiques!

More in this category