Quan es treballa amb el processament d’imatges en .NET, una necessitat comuna és fusionar múltiples imatges - sovint de diferents mides- en una sola sortida. Casos d’ús típics inclouen col·laboracions, fulles de bretxa, fulls de contacte, o banners de màrqueting. Aquest tutorial mostra com fusió de les imatges utilitzant Aspose.Imaginant per .Net amb control precís sobre el disseny: axis (horitzontal/vertical), alineament (top/center/bottom i esquerra/centre/dreta), exterior padding, i espai entre imatges. També cobrirem un enfocament segur, cross-platform que es basa en Aspose Graphics El foc.

Què construiràs

  • Layout: horitzontal o vertical

    • L’aportació: *

  • Llistat horitzontal → alineació vertical: Top, Middle, Bottom

  • L’alineació horitzontal és vertical: Left, Center, Right

  • Padding: exterior pading i inter-item espaci

  • **Background: *Full de color sòlid

  • Formats: càrrega de formats mixtos (JPG, PNG, etc.), excepte a png/JPEG

Exemple complet

using System;
using System.Collections.Generic;
using System.IO;
using Aspose.Imaging;
using Aspose.Imaging.ImageOptions;

namespace ImagingMergeDemo
{
    public enum MergeAxis { Horizontal, Vertical }
    public enum VAlign { Top, Middle, Bottom }
    public enum HAlign { Left, Center, Right }

    public static class ImageMerger
    {
        /// <summary>
        /// Merges input images into a single image with alignment and padding.
        /// </summary>
        /// <param name="inputPaths">List of source image file paths.</param>
        /// <param name="axis">Horizontal or Vertical stacking.</param>
        /// <param name="outerPadding">Padding around the whole collage (in pixels).</param>
        /// <param name="spacing">Spacing between images (in pixels).</param>
        /// <param name="bgColor">Background color for the canvas.</param>
        /// <param name="verticalAlign">Only used when axis == Horizontal (Top/Middle/Bottom inside the row).</param>
        /// <param name="horizontalAlign">Only used when axis == Vertical (Left/Center/Right inside the column).</param>
        /// <param name="outputPath">Destination file path. Extension determines encoder (e.g., .png, .jpg).</param>
        public static void Merge(
            IReadOnlyList<string> inputPaths,
            MergeAxis axis,
            int outerPadding,
            int spacing,
            Color bgColor,
            VAlign verticalAlign,
            HAlign horizontalAlign,
            string outputPath)
        {
            if (inputPaths is null || inputPaths.Count == 0)
                throw new ArgumentException("No input images provided.");

            // Load all images first so we can compute canvas size.
            var loaded = new List<Image>(inputPaths.Count);
            try
            {
                foreach (var p in inputPaths)
                {
                    var img = Image.Load(p);
                    loaded.Add(img);
                }

                // Compute canvas size.
                // For horizontal axis: width = sum(widths) + spacings + 2*outerPadding
                // height = max(heights) + 2*outerPadding
                // For vertical axis:   height = sum(heights) + spacings + 2*outerPadding
                // width  = max(widths) + 2*outerPadding
                int totalWidth, totalHeight;

                if (axis == MergeAxis.Horizontal)
                {
                    int sumWidths = 0, maxH = 0;
                    for (int i = 0; i < loaded.Count; i++)
                    {
                        sumWidths += loaded[i].Width;
                        maxH = Math.Max(maxH, loaded[i].Height);
                    }
                    totalWidth = sumWidths + ((loaded.Count - 1) * spacing) + 2 * outerPadding;
                    totalHeight = maxH + 2 * outerPadding;
                }
                else
                {
                    int sumHeights = 0, maxW = 0;
                    for (int i = 0; i < loaded.Count; i++)
                    {
                        sumHeights += loaded[i].Height;
                        maxW = Math.Max(maxW, loaded[i].Width);
                    }
                    totalHeight = sumHeights + ((loaded.Count - 1) * spacing) + 2 * outerPadding;
                    totalWidth = maxW + 2 * outerPadding;
                }

                // Create canvas (use PNG by default for lossless output; you can switch to JPEGOptions)
                using var canvas = Image.Create(new PngOptions(), totalWidth, totalHeight);

                // Draw on canvas
                using var g = new Graphics(canvas);
                g.Clear(bgColor);

                int cursorX = outerPadding;
                int cursorY = outerPadding;

                for (int i = 0; i < loaded.Count; i++)
                {
                    var img = loaded[i];

                    int drawX, drawY;

                    if (axis == MergeAxis.Horizontal)
                    {
                        // X flows left -> right
                        drawX = cursorX;

                        // Y depends on vertical alignment vs tallest height
                        drawY = verticalAlign switch
                        {
                            VAlign.Top    => outerPadding,
                            VAlign.Middle => outerPadding + (totalHeight - 2 * outerPadding - img.Height) / 2,
                            VAlign.Bottom => outerPadding + (totalHeight - 2 * outerPadding - img.Height),
                            _ => outerPadding
                        };

                        // Draw and move X cursor
                        g.DrawImage(img, new Rectangle(drawX, drawY, img.Width, img.Height));
                        cursorX += img.Width + spacing;
                    }
                    else
                    {
                        // Y flows top -> bottom
                        drawY = cursorY;

                        // X depends on horizontal alignment vs widest width
                        drawX = horizontalAlign switch
                        {
                            HAlign.Left   => outerPadding,
                            HAlign.Center => outerPadding + (totalWidth - 2 * outerPadding - img.Width) / 2,
                            HAlign.Right  => outerPadding + (totalWidth - 2 * outerPadding - img.Width),
                            _ => outerPadding
                        };

                        // Draw and move Y cursor
                        g.DrawImage(img, new Rectangle(drawX, drawY, img.Width, img.Height));
                        cursorY += img.Height + spacing;
                    }
                }

                // Save with encoder that matches extension
                SaveByExtension(canvas, outputPath);
            }
            finally
            {
                // Dispose loaded images
                foreach (var img in loaded)
                    img.Dispose();
            }
        }

        private static void SaveByExtension(Image image, string outputPath)
        {
            var ext = Path.GetExtension(outputPath).ToLowerInvariant();
            ImageOptionsBase opts = ext switch
            {
                ".jpg" or ".jpeg" => new JpegOptions { Quality = 90 },
                ".png"            => new PngOptions(),
                _                 => new PngOptions() // default to PNG
            };
            image.Save(outputPath, opts);
        }
    }

    // Example usage
    public class Program
    {
        public static void Main()
        {
            var inputs = new List<string>
            {
                "image1.jpg",
                "image2.png",
                "image3.jpg"
            };

            // Horizontal strip, vertically centered, with padding/spacing
            ImageMerger.Merge(
                inputPaths: inputs,
                axis: MergeAxis.Horizontal,
                outerPadding: 20,
                spacing: 10,
                bgColor: Color.White,
                verticalAlign: VAlign.Middle,
                horizontalAlign: HAlign.Center, // ignored for horizontal axis
                outputPath: "merged_horizontal.png"
            );

            // Vertical stack, horizontally right-aligned
            ImageMerger.Merge(
                inputPaths: inputs,
                axis: MergeAxis.Vertical,
                outerPadding: 20,
                spacing: 12,
                bgColor: Color.FromArgb(255, 245, 245, 245),
                verticalAlign: VAlign.Middle,    // ignored for vertical axis
                horizontalAlign: HAlign.Right,
                outputPath: "merged_vertical.jpg"
            );
        }
    }
}

Guia de pas a pas

Pas 1: Carregar imatges

Carregar totes les imatges d’entrada amb Image.Load(path)Mantenir-los vius fins després de dibuixar, després dissenyar.

Pas 2: Determina la mida de la sortida

  • Layout horitzontal: ample = suma d’amplituds + espais + patinatge exterior; alçada = màxim altitud + pàrquing exterior.
  • Layout vertical: altitud = suma d’altituds + espais + patinatge exterior; ample = màxim de latitud i patinació exterior.

Pas 3: Crear el Canvas de sortida

Creació utilitzant Image.Create(new PngOptions(), width, height) (o JpegOptions si vostè prefereix la sortida perduda). clar amb un color de fons.

Pas 4: Configuració d’alineació i ajustament

  • Fusió horitzontal → calcular Y per Top / Middle / Bottom.
  • Fusió vertical → calcular X per Left / Center / Right.
  • Apply outerPadding i spacing de manera consistent.

Pas 5: dibuixar cada imatge

Use Graphics.DrawImage(image, new Rectangle(x, y, image.Width, image.Height)).

Pas 6: Salvar el resultat

Seleccionar l’encodador basat en la extensió del nom de fil de sortida (per exemple, .png → PngOptions, .jpg → JpegOptions { Quality = … }).

Les millors pràctiques

  • Normalitza els formats: Si necessites fons transparents, salva com a PNG. Per a fitxers més petits sense transparència, utilitzeu JPEG i tune Quality.
  • Guardrails: Validar la llista d’ingressos, gestionar els arxius desapareguts i considerar les dimensions màximes de canvas per evitar OOM.
    • Disposa de: Image, Graphics Està disponible - Utilització using o try/finally.
  • ** Consistència de colors**: Si les entrades tenen tipus de color mixtes, es basa en els defectes d’Aspose o es converteix explícitament quan sigui necessari.
  • Batching: Per a grups grans, flueix les sortides mentre vas o crea múltiples taules / pàgines.

More in this category