Het roteren van beelden door een willekeurige hoek met een transparante achtergrond is een frequente vereiste voor galerijen, dashboards en ontwerptools in .NET. Aspose.Imaging voor .Net biedt een directe API om een afbeelding op te laden, om het te roten via een aangepaste hoeken en te slaan in een format dat transparantie ondersteunt.

Volledige voorbeeld

// 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}");
                }
            }
        }
    }
}
  • Hoe het werkt *
  • Image.Load open de bron. de code checks en casts naar RasterImage voor raster operaties.
  • raster.Rotate(angle, expandCanvas, Color.Transparent) rotatie door elke mate van waarde.
  • besparen met PngOptions Het behoudt transparantie.
  • Batch-modus loopt een directoryboom, draait ondersteunde formaten en schrijft PNG’s.

Step-by-step gids

1) De afbeelding opladen

Gebruik Image.Load om de bronbestand te openen.Cast to RasterImage Als je specifieke leden nodig hebt.

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

2) Roteren door elke hoek

bellen Rotate(angle, expandCanvas, backgroundColor).

  • angle is in graden
  • expandCanvas = true vermijd kletsen door de kanvas te resiseren om aan de roterde grenzen te passen
  • Color.Transparent houdt de achtergrond transparant als het uitgangsformaat alfa ondersteunt
image.Rotate(17, true, Color.Transparent);

3) Speel op een format dat transparantie ondersteunt

PNG ondersteunt transparantie. gebruik PngOptions om de roterde output te redden met de alfa-kanaal bewaard.

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

Praktische opties

    • Vermijd clipping*: set expandCanvas = true bij het roteren door niet-rechte hoeken
  • Opaque achtergronden: pass een solide Color In plaats van Color.Transparent Als je een gevuld achtergrond wilt
  • Verliesloze output: PNG voor UI’s, logos en overladen die crisp-zijden en transparantie nodig hebben
  • Fotografie: als u geen transparantie nodig hebt, kan JPEG besparen om de bestandgrootte te verminderen

Gemeenschappelijke pitfalls en fixes

    • Transparante achtergrond verloren *Save met PngOptions of een ander formaat dat alpha ondersteunt. JPEG ondersteemt geen transparantie.
  • De delen van de afbeelding verdwijnen na rotatieGebruik expandCanvas = true om de kanvas te groeien zodat het roterde inhoud past.

  • Gevangen na de rotatieRotatie maakt gebruik van bibliotheek-default.Als uw bron in lage resolutie is, overweeg om de ingang naar een hogere resolutie te herstellen voordat u rotat, dan afschakelen na het opslaan om zichtbare artefacten te verminderen.

    • geheugen en grote afbeeldingen*Plaats afbeeldingen snel en vermijd het opladen van vele grote bestanden tegelijkertijd.

Mini checklijst

  • Laden met Image.Load
  • Roteren met image.Rotate(angle, true, Color.Transparent)
  • Save met new PngOptions() Voor transparantie
  • Gebruik een solide achtergrond als transparantie niet nodig is
  • Valideer de output visueel voor sleutelactiva

FAQ

**Welke formaten houden na rotatie transparantie*PNG en andere alfa-capable formaten. JPEG behoudt geen transparantie.

  • Hoe kan ik roteren zonder de kanvas te vergroten*Pass expandCanvas = falseInhoud buiten de oorspronkelijke grenzen zal worden geklipt.

  • Ik kan door elke hoek roteren*Ja. De hoekparameters accepteren elke numerische gradenwaarde.

More in this category