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 naarRasterImage
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 gradenexpandCanvas = true
vermijd kletsen door de kanvas te resiseren om aan de roterde grenzen te passenColor.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
- Vermijd clipping*: set
- Opaque achtergronden: pass een solide
Color
In plaats vanColor.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.
- Transparante achtergrond verloren *Save met
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 = false
Inhoud buiten de oorspronkelijke grenzen zal worden geklipt.Ik kan door elke hoek roteren*Ja. De hoekparameters accepteren elke numerische gradenwaarde.
More in this category
- Het optimaliseren van geanimeerde GIF's in .NET met behulp van Aspose.Imaging
- Optimaliseren van multi-page TIFF's voor archief in .NET met Aspose
- Convert TIFF naar PDF in C# met Aspose.Imaging
- Cropping Product Images voor E-Commerce Platforms met behulp van Aspose.Imaging voor .NET
- Data-Driven Animaties in .NET met Aspose.Imaging