Choisir la langue
  1. Products
  2. Aspose.Imaging
  3. Image merge
clearbit icon

Fusionner des images pour .NET

Des outils pratiques pour fusionner plusieurs images en une seule, créant ainsi des collages d'images ou de photos. large gamme de formats d'images.

Acheter pour $99
Partager
Instagram Logo Dribbble Logo Twitter Logo Youtube Logo

Comment fusionner le fichier images à l'aide de la bibliothèque .NET

Afin de fusionner les fichiers image en un seul, nous utiliserons Aspose.Imaging pour l'API .NET qui est une API de manipulation d'image riche en fonctionnalités, puissante et facile à utiliser pour la plate-forme Internet.

1
Install-Package Aspose.Imaging

Fusionner des images via .NET

Vous avez besoin Aspose.Imaging Merge pour licence limitée .NET pour essayer le code dans votre environnement.

  1. Chargez les images d’entrée pour collecter les données de référence.
  2. Créer une image de sortie en tenant compte des données de référence d'entrée et fusionner la disposition (horizontale, verticale, mosaïque, etc.)
  3. Créez la classe Graphics pour l'image de sortie et dessinez les images d'entrée à l'aide de la stratégie de fusion sélectionnée.
  4. Vous pouvez pré-redimensionner les images d'entrée pour les adapter à la même taille ou à la taille requise.

Configuration requise

Assurez-vous simplement que vous disposez des conditions préalables suivantes.

  • Microsoft Windows ou un système d'exploitation compatible avec .NET Core
  • Environnement de développement comme Visual Studio Code ou Microsoft Visual Studio.
  • Aspose.Imaging pour .NET DLL référencée dans votre projet.
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
using System;
 using Aspose.Imaging;
 using Aspose.Imaging.FileFormats.Png

namespace CSharpTutorials
{
    enum MergeDirection
    {
           Horizontal = 0,
           Vertical = 1
    }

    class Program
    {
        static void Main(string[] args)
        {
            if(args.Lenght<3)
            {
                Console.WriteLine("Please specify inpur folder with images to merge and ");
                Console.WriteLine("wildcard mask of the input images (i.e. *.png or *.jpg) and");
                Console.WriteLine("output folder for merge image(s)");
                return;
            }

            Metered metered = new Metered();
            metered.SetLicense("***********", // public key
                               "***********"  // private key
                              );
            // This code merges input images into output one
            var images = new List<Image>();

            int maxWidth = 0;
            int maxHeight = 0;
            int totalWidth = 0;
            int totalHeight = 0;            

            string InputDirectory = args[0];
            string Mask = args[1];
                
            foreach (var fileName in Directory.GetFiles(InputDirectory, Mask))
            {
                    var image = Image.Load(fileName);
    
                    totalWidth += image.Width;
    
                    if (image.Width > maxWidth)
                    {
                        maxWidth = image.Width;
                    }
    
                    totalHeight += image.Height;
    
                    if (image.Height > maxHeight)
                    {
                        maxHeight = image.Height;
                    }
    
                    images.Add(image);
            }
    
            string OutputDirectory = args[2];
            if (!Directory.Exists(OutputDirectory))
            {
                Directory.CreateDirectory(OutputDirectory);
            }

            try
            {
                var outputPath = Path.Combine(OutputDirectory, "merge_horizontal.jpg");
                var outputOptions = new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha };
                MergeImages(images, MergeDirection.Horizontal, totalWidth, maxHeight, outputPath, outputOptions);
    
                outputPath = Path.Combine(OutputDirectory, "merge_vertical.jpg");
                MergeImages(images, MergeDirection.Vertical, totalHeight, maxWidth, outputPath, outputOptions);
            }
            finally
            {
                images.ForEach(image => image.Dispose());
            }
        }            

        void MergeImages(List<Image> images, MergeDirection direction, int totalSize, int maxSize, string outputPath, ImageOptionsBase outputImageOptions)
        {
            int targetWidth, targetHeight;
                
            switch (direction)
            {
                case MergeDirection.Horizontal:
                {
                    targetWidth = totalSize;
                    targetHeight = maxSize;
                    break;
                }
                case MergeDirection.Vertical:
                {
                    targetWidth = maxSize;
                    targetHeight = totalSize;
                    break;
                }
                default:
                    throw new ArgumentException("Unexpected merge direction");
            }
                
            using (Stream stream = new MemoryStream())
            {
                outputOptions.Source = new StreamSource(stream);
            
                using (var image = Image.Create(outputOptions, targetWidth, targetHeight))
                {
                    image.BackgroundColor = Color.White;
                    var graphics = new Graphics(image);
            
                    float x = 0, y = 0;
                    images.ForEach(image =>
                    {
                        graphics.DrawImage(image, new RectangleF(x, y, image.Width, image.Height));
            
                        if (direction == MergeDirection.Horizontal)
                        {
                            x += image.Width;
                        }
            
                        if (direction == MergeDirection.Vertical)
                        {
                            y += image.Height;
                        }
                    });
                                
                    image.Save(outputPath);
                }
            }
        }
    }
}

You may find other allowed image merge scenarious and examples here