La rotation d’images à un angle arbitraire avec un fond transparent est une exigence fréquente pour les galeries, les panneaux et les outils de conception dans .NET. Aspose.Imaging pour .Net fournit une API directe pour charger une image, la tourner à l’angle personnalisé et sauvegarder dans un format qui soutient la transparence.

Exemple complet

// File: Program.cs
// Requires NuGet: Aspose.Imaging

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

namespace RotateTransparentDemo
{
    public static class Program
    {
        public static int Main(string[] args)
        {
            try
            {
                if (args.Length == 0)
                {
                    // Single-file demo paths. Replace with your own files or pass CLI args.
                    var input  = "input.png";         // source can be PNG, JPG, etc.
                    var output = "rotated-output.png"; // must be PNG to preserve transparency
                    RotateSingle(input, output, angleDegrees: 17f, expandCanvas: true);
                    Console.WriteLine($"Saved: {output}");
                    return 0;
                }

                // CLI:
                // 1) Single file:
                //    RotateTransparentDemo.exe <inputPath> <outputPath> <angleDegrees> [expandCanvas:true|false]
                //
                // 2) Batch folder:
                //    RotateTransparentDemo.exe --batch <inputDir> <outputDir> <angleDegrees> [expandCanvas:true|false]

                if (args[0].Equals("--batch", StringComparison.OrdinalIgnoreCase))
                {
                    if (args.Length < 4)
                    {
                        Console.Error.WriteLine("Usage: --batch <inputDir> <outputDir> <angleDegrees> [expandCanvas:true|false]");
                        return 2;
                    }

                    var inputDir     = args[1];
                    var outputDir    = args[2];
                    var angle        = float.Parse(args[3]);
                    var expandCanvas = args.Length >= 5 ? bool.Parse(args[4]) : true;

                    BatchRotate(inputDir, outputDir, angle, expandCanvas);
                    Console.WriteLine($"Batch complete. Output in: {outputDir}");
                    return 0;
                }
                else
                {
                    if (args.Length < 3)
                    {
                        Console.Error.WriteLine("Usage: <inputPath> <outputPath> <angleDegrees> [expandCanvas:true|false]");
                        return 2;
                    }

                    var inputPath    = args[0];
                    var outputPath   = args[1];
                    var angle        = float.Parse(args[2]);
                    var expandCanvas = args.Length >= 4 ? bool.Parse(args[3]) : true;

                    RotateSingle(inputPath, outputPath, angle, expandCanvas);
                    Console.WriteLine($"Saved: {outputPath}");
                    return 0;
                }
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine("Error: " + ex.Message);
                return 1;
            }
        }

        /// <summary>
        /// Rotates a single image by an arbitrary angle and preserves transparency in the output PNG.
        /// </summary>
        private static void RotateSingle(string inputPath, string outputPath, float angleDegrees, bool expandCanvas)
        {
            if (!File.Exists(inputPath))
                throw new FileNotFoundException("Input image not found.", inputPath);

            // If you expect large images or batches, you can enable disk cache to reduce RAM pressure:
            // Aspose.Imaging.Cache.CacheType   = Aspose.Imaging.Cache.CacheType.CacheOnDisk;
            // Aspose.Imaging.Cache.CacheFolder = Path.GetFullPath(".imaging-cache");
            // Aspose.Imaging.Cache.CacheSize   = 512L * 1024 * 1024; // 512 MB

            using (var image = Image.Load(inputPath))
            {
                // Raster operations are available on RasterImage
                if (image is not RasterImage raster)
                    throw new InvalidOperationException("Loaded image is not a raster image.");

                // Rotate by an arbitrary angle. Set expandCanvas to true to avoid clipping.
                // Color.Transparent keeps the background transparent for alpha-capable formats.
                raster.Rotate(angleDegrees, expandCanvas, Color.Transparent);

                // Save as PNG to preserve alpha channel
                var pngOptions = new PngOptions
                {
                    // Most cases do not need explicit color type; leaving defaults preserves alpha.
                    // Uncomment if you want to force RGBA:
                    // ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha
                };

                // Ensure output directory exists
                Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(outputPath)) ?? ".");

                raster.Save(outputPath, pngOptions);
            }
        }

        /// <summary>
        /// Rotates all supported images in a folder and writes PNG outputs with transparency preserved.
        /// </summary>
        private static void BatchRotate(string inputDir, string outputDir, float angleDegrees, bool expandCanvas)
        {
            if (!Directory.Exists(inputDir))
                throw new DirectoryNotFoundException("Input directory not found: " + inputDir);

            Directory.CreateDirectory(outputDir);

            // Common raster extensions. Adjust as needed.
            var extensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
            {
                ".png", ".jpg", ".jpeg", ".bmp", ".gif", ".tif", ".tiff", ".webp"
            };

            var files = Directory.GetFiles(inputDir, "*.*", SearchOption.AllDirectories);
            foreach (var file in files)
            {
                var ext = Path.GetExtension(file);
                if (!extensions.Contains(ext))
                    continue;

                var rel     = Path.GetRelativePath(inputDir, file);
                var relBase = Path.ChangeExtension(rel, ".png"); // output is PNG to keep transparency
                var outPath = Path.Combine(outputDir, relBase);

                Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(outPath)) ?? ".");

                try
                {
                    RotateSingle(file, outPath, angleDegrees, expandCanvas);
                    Console.WriteLine($"OK  {rel} -> {relBase}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"ERR {rel}: {ex.Message}");
                }
            }
        }
    }
}
  • Comment ça fonctionne *
  • Image.Load ouvre la source. le code vérifie et lance à RasterImage pour les opérations de raster.
  • raster.Rotate(angle, expandCanvas, Color.Transparent) Routes à n’importe quel degré.
  • Économiser avec PngOptions préserver la transparence.
  • Le mode Batch passe un arbre de directory, tourne les formats soutenus et écrit les PNG.

Guide pas à pas

1) Remplissez l’image

Utiliser Image.Load ouvrir le fichier source.Cast à RasterImage Si vous avez besoin de membres spécifiques.

using (var image = (RasterImage)Image.Load(inputPath))
{
    // work with the image here
}

2) Router par tout angle

Appel Rotate(angle, expandCanvas, backgroundColor).

  • angle Il est en degrés
  • expandCanvas = true Évitez le clippage en repoussant les canvas pour s’adapter aux limites rotées
  • Color.Transparent maintient le fond transparent si le format de sortie prend en charge l’alpha
image.Rotate(17, true, Color.Transparent);

3) Enregistrer dans un format qui soutient la transparence

PNG soutient la transparence. PngOptions pour sauver la sortie rotée avec le canal alpha conservé.

image.Save(outputPath, new PngOptions());

Options pratiques

    • Éviter les clips * : Settings expandCanvas = true Quand on tourne par des angles non droites
  • Résultats opacés: passer un solide Color Au lieu de Color.Transparent Si vous voulez un fond rempli
  • Production sans pertes: préférez le PNG pour les UI, les logos et les surplacements qui nécessitent des bords de crisp et de transparence
  • ** Photographie**: si vous n’avez pas besoin de transparence, économiser comme JPEG peut réduire la taille du fichier

Pistes communes et fixes

    • Le fond transparent perdu*Sauver avec PngOptions ou un autre format qui soutient alpha. JPEG ne supporte pas la transparence.
  • Les parties de l’image sont manquantes après la rotationUtiliser expandCanvas = true Pour développer les canvas afin que le contenu tourné s’adapte.

    • Les bords poursuivis après la rotation*Si votre source est à faible résolution, réfléchissez à redémarrer l’entrée à une résolution plus élevée avant de tourner, puis descendez après avoir sauvé pour réduire les objets visibles.
    • Mémoire et grandes images *Placez les images rapidement et évitez de charger plusieurs grands fichiers à la fois. Configurez le caching disque pour les gros lots si nécessaire.

Mini liste de vérification

  • Charge avec Image.Load
  • Rotage avec image.Rotate(angle, true, Color.Transparent)
  • Sauver avec new PngOptions() Pour la transparence
  • Utilisez un fond solide si la transparence n’est pas requise
  • Valider visuellement le rendement pour les actifs clés

FAQ

Quels formats maintiennent la transparence après la rotationPNG et autres formats alpha-capables. JPEG ne maintient pas la transparence.

  • Comment rouler sans élargir le canvas*Passe expandCanvas = falseLe contenu en dehors des limites originales sera cliqué.

  • Je peux rouler par n’importe quel angle*Le paramètre angle accepte toute valeur de degré numérique.

More in this category