Cuando se trabaja con el procesamiento de imágenes en .NET, una necesidad común es combinar varias imágenes -a menudo de diferentes tamaños- en una única salida. Casos típicos de uso incluyen colágenas, hojas de sprite, follas de contacto, o banners de marketing. Este tutorial muestra cómo fusionar imágenes utilizando Aspose.Imaging para .Net con control preciso sobre el diseño: ácido (horizontal/vertical), alineación (top/center/bottom y izquierda/centro/derecha), padding exterior, y espaciamiento entre imágenes. También cubriremos un enfoque seguro, cross-platform que se basa en Aspose Graphics El fuego.

Lo que construirás

  • *Layout: horizontal o vertical

    • El alquiler: *

  • Layout horizontal → alineación vertical: Top, Middle, Bottom

  • Layout vertical → alineación horizontal: Left, Center, Right

  • Padding: padding exterior y espaciamiento inter-item

  • **Background: * lleno de color sólido

  • Formatos: cargar formatos mixtos (JPG, PNG, etc.), con excepción de Png/JPEG

Ejemplo completo

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

Guía paso a paso

Paso 1: Cargar imágenes

Cargar todas las imágenes de entrada con Image.Load(path)Mantenerlos vivos hasta después de dibujar, luego disolver.

Paso 2: Determina el tamaño de la salida

  • Layote horizontal: ancho = suma de latitudes + espacios + paddling exterior; altura = altura máxima + Padding exterior.
  • Layo vertical: altura = suma de alturas + espacios + paddling exterior; ancho = anchura máxima + Padding exterior.

Paso 3: Crea el canvas de salida

Creación utilizando Image.Create(new PngOptions(), width, height) (o JpegOptions si prefiere la salida perdida). claro con un color de fondo.

Paso 4: Configure alineación y ajuste

  • Horizontal fusión → calcular Y por Top / Middle / Bottom.
  • Vertical fusión → calcular X por Left / Center / Right.
  • Apply outerPadding y spacing de manera consistente.

Paso 5: Descargar cada imagen

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

Paso 6: Salva el resultado

Seleccione el codificador basado en la extensión de nombre de fil de salida (por ejemplo, .png → PngOptions, .jpg → JpegOptions { Quality = … }).).

Mejores Prácticas

  • Normalizar los formatos: Si necesita un fondo transparente, salve como PNG. Para archivos más pequeños sin transparencia, utilice JPEG y tune Quality.
  • Guardrails: Validar la lista de entradas, gestionar los archivos desaparecidos y considerar las dimensiones de canvas máximas para evitar OOM.
    • Dispone de: Image, Graphics Disponible - Utilización using o try/finally.
  • Color consistencia: Si las entradas tienen tipos de color mixtos, depender de los defectos de Aspose, o convertir explícitamente cuando sea necesario.
  • Batching: Para los grandes conjuntos, fluye las fuentes a medida que va o crea múltiples tapas/páginas.

More in this category