Tworzenie ręcznych aranżacji mosaic to nieśmiały i błędny proces, zwłaszcza gdy zajmuje się kilkadziesiąt lub setkami obrazów. ta zadania staje się jeszcze bardziej wymagająca, jeśli musisz utrzymać spójność w różnych projektach lub kampaniach. Z pojawieniem się narzędzi automatyzacji, takich jak Aspose.Imaging dla .NET, deweloperzy mogą teraz bez wysiłku stworzyć doskonałe, powtarzające się mozaiki obrazu.

W tym artykule na blogu dowiemy się, jak zautomatyzować proces łączenia wielu obrazów w układ sieciowy za pomocą Aspose.Imaging dla .NET. Pokryjemy wszystko od ustawienia środowiska i organizowania obrazu źródłowego do resetowania i uporządkowania ich w formacie sieciowym.

Warunki

Przed zanurzeniem się w kod, upewnij się, że masz następujące warunki:

  • Wizual Studio 2019 lub później
  • .NET 6.0 lub nowszy (lub .Net Framework 4.6.2+)
  • Aspose.Imaging dla .NET z NuGet

Przykład kodu: Automatyzacja obrazów 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>();
    }
}

Zrozumienie kodeksu

Przyjrzyjmy się kluczowym elementom tej realizacji:

Krok 1: Początkowe ustawienie

Najpierw rozpoczniemy licencję mierzoną i pobieramy pliki wejściowe:

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

Ta sekcja zawiera wymagane licencje i przesyła wszystkie obrazy z określonego folderu na listę.

Krok 2: Obliczanie wymiarów kanałów wyjściowych

Następnie obliczamy wymiary kanału wyjściowego na podstawie liczby kolejek i kolumn:

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

Tutaj określamy szerokość i wysokość kompozytowego obrazu w oparciu o wymiary siatki.

Krok 3: Pobieranie i odtwarzanie obrazów

Teraz pobieramy każdy obraz z listy i odświeżamy go, aby dopasował się do sieci:

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

Ten strzałek ładuje każdy obraz i odświeża go do jednolitego rozmiaru przed umieszczeniem go w siatce.

Krok 4: Ustawienie obrazów w sieci

Następnie obliczamy pozycję każdego obrazu w sieci i wyciągamy go za pomocą Graphics.DrawImage:

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

graphics.DrawImage(image, xPosition, yPosition);

Ta część zapewnia, że każdy obraz jest prawidłowo umieszczony w kompozytowym obrazie na podstawie jego indeksu.

Krok 5: Oszczędzanie kompozytowego obrazu

Wreszcie przechowujemy kompozytowy obraz do określonej ścieżki wyjścia:

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

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

Ten odcinek przechowuje ostatni obraz mosaiki do pliku.

konkluzja

W tym artykule na blogu dowiedzieliśmy się, jak zautomatyzować proces tworzenia mosaiki obrazu za pomocą Aspose.Imaging dla .NET. Postępując zgodnie z krokami przedstawionymi w tym przewodniku, można łatwo stworzyć konsekwentne i wizualnie atrakcyjne układy sieci programicznie.

Czuć się wolny do eksperymentu z różnymi konfiguracjami i ulepszeniami, aby dostosować rozwiązanie do Twoich konkretnych potrzeb!

More in this category