Das Drehen von Bildern durch einen arbiträren Winkel mit einem transparenten Hintergrund ist eine häufige Anforderung für Galerien, Dashboards und Design-Tools in .NET. Aspose.Imaging für .Net bietet eine direkte API, um ein Bild zu laden, es durch ein angepasstes Winkel zu drehen und zu einem Format zu speichern, das Transparenz unterstützt.

Vollständiges Beispiel

// 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}");
                }
            }
        }
    }
}
  • Wie es funktioniert *
  • Image.Load öffnet die Quelle. Der Code überprüft und kastet auf RasterImage für Raster Operationen.
  • raster.Rotate(angle, expandCanvas, Color.Transparent) Routen mit jedem Grad Wert.
  • Sparen mit PngOptions die Transparenz beibehalten.
  • Das Batch-Modus verläuft ein Registerbaum, dreht unterstützte Formate und schreibt PNGs.

Schritt für Schritt Guide

1) Laden Sie das Bild

Use Image.Load zum Öffnen der Quelldatei.Cast to RasterImage wenn Sie Raster-spezifische Mitglieder benötigen.

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

2) Routen aus jeder Ecke

Call Rotate(angle, expandCanvas, backgroundColor).

  • angle ist in Grad
  • expandCanvas = true Vermeiden Sie Klippen, indem Sie die Kanvas umzusetzen, um die rotierten Grenzen anzupassen
  • Color.Transparent Halte den Hintergrund transparent, wenn das Ausgangsformat Alpha unterstützt
image.Rotate(17, true, Color.Transparent);

3) Speichern Sie in ein Format, das Transparenz unterstützt

PNG unterstützt Transparenz. PngOptions um den rotierten Ausgang mit dem alpha-Kanal bewahrt zu speichern.

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

Praktische Optionen

    • Vermeiden Sie Clipping*: Set expandCanvas = true wenn Sie durch nicht rechte Ecke drehen
  • Opaque Hintergründe: Pass eine solide Color Statt der Color.Transparent Wenn Sie einen gefüllten Hintergrund wollen
  • Beschädigungslose Produktion: Vorzugsweise PNG für UI, Logos und Übersetzungen, die Krisp-Einen und Transparenz benötigen
  • Fotografie: Wenn Sie keine Transparenz benötigen, können JPEG-Sparungen die Dateigröße verringern

Gemeinsame Pitfalls und Fixes

    • Transparente Hintergründe verloren*Sparen Sie mit PngOptions oder ein anderes Format, das alpha unterstützt. JPEG Unterstützt keine Transparenz.

  • **Teile des Bildes verschwinden nach Rotation*Use expandCanvas = true um die Kanvas zu wachsen, so dass der rotierte Inhalt passt.

    • Gefahren nach der Rotation*Wenn Ihre Quelle eine niedrige Auflösung hat, berücksichtigen Sie, die Eingabe zu einer höheren Resolution vor der Rotation zurückzuziehen, dann nach dem Einsparen abzuschalten, um sichtbare Artefakte zu reduzieren.
    • Gedächtnis und große Bilder*Stellen Sie Bilder schnell bereit und vermeiden Sie, viele große Dateien gleichzeitig zu laden. Konfigurieren Sie Disk-Caching für große Battchen, wenn nötig.

Mini Checkliste

  • Laden mit Image.Load
  • Rotation mit image.Rotate(angle, true, Color.Transparent)
  • Sparen Sie mit new PngOptions() Für Transparenz
  • Verwenden Sie einen soliden Hintergrund, wenn Transparenz nicht erforderlich ist
  • Validieren Sie die Produktion visuell für Schlüsselvermögenswerte

FAQ

**Welche Formate halten nach Rotation Transparenz*PNG und andere alpha-fähige Formate. JPEG behält keine Transparenz.

Wie kann ich rotieren, ohne die Kanvas zu erweiternPass expandCanvas = falseInhalte außerhalb der ursprünglichen Grenzen werden geklipt.

  • Ich kann mit jedem Winkel drehen*Ja. Der Winkelparameter akzeptiert jede numerische Gradwert.

More in this category