Crearea manuală a layoutelor mosaice este un proces plictisitor și lipsit de erori, mai ales atunci când se ocupă cu zeci sau sute de imagini. Această sarcină devine chiar mai dificilă dacă trebuie să mențineți coerența pe parcursul mai multor proiecte sau campanii. Cu apariția instrumentelor de automatizare cum ar fi Aspose.Imagining pentru .NET, dezvoltatorii pot acum să creeze perfect, repetabile imaginii mosici fără efort.

În acest post de blog, vom explora cum să automatizăm procesul de alungare a mai multor imagini într-un layout de rețea folosind Aspose.Imaging pentru .NET. Vom acoperi totul de la setarea mediului dvs. și organizarea imaginilor de sursă până la reorganizarea și aranjarea lor în format de grid.

Prevederile

Înainte de a îneca în cod, asigurați-vă că aveți următoarele cerințe:

  • Visual Studio 2019 sau mai târziu
  • .NET 6.0 sau mai târziu (sau .Net Framework 4.6.2+)
  • Aspose.Imaging pentru .NET de la NuGet

Exemplu de cod: Automatizarea imaginii 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>();
    }
}

Înțelegerea codului

Să descărcăm elementele cheie ale acestei implementări:

Pasul 1: Setarea inițială

În primul rând, inițializăm licența măsurată și încărcăm fișierele de intrare:

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

Această secțiune stabilește licențele necesare și încărcă toate imaginile dintr-un folder specific într-o listă.

Pasul 2: Calcularea dimensiunilor Canvas de ieșire

Următor, calculăm dimensiunile canapei de ieșire pe baza numărului de rânduri și coloane:

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

Aici, determinăm amploarea și înălțimea imaginii compuse pe baza dimensiunilor rețelei.

Pasul 3: Încărcarea și revizuirea imaginilor

Acum, încărcăm fiecare imagine din listă și o redimensionăm pentru a se potrivi în interiorul rețelei:

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

Această scanare încărcă fiecare imagine și o resizează la o dimensiune uniformă înainte de a o pune în rețea.

Pasul 4: Aranjarea imaginilor în rețea

Apoi calculăm poziția fiecărei imagini în interiorul rețelei și le desenăm folosind Graphics.DrawImage:

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

graphics.DrawImage(image, xPosition, yPosition);

Această parte se asigură că fiecare imagine este plasată corect în interiorul imaginii compuse pe baza indexului său.

Pasul 5: Salvați imaginea compusă

În cele din urmă, salvăm imaginea compusă la o cale de ieșire specificată:

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

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

Acest scan salvează ultima imagine mosaică într-un fișier.

concluziile

În acest post de blog, am explorat cum să automatizăm procesul de creare a mosaicelor de imagine folosind Aspose.Imaging pentru .NET. Urmând pașii descrise în acest ghid, puteți crea cu ușurință în mod programat layout-uri de rețea coerente și vizual atrăgătoare.

Simți-vă liber să experimentați cu diferite configurații și îmbunătățiri pentru a adapta soluția la nevoile dvs. specifice!

More in this category