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ésexpandCanvas = true
Évitez le clippage en repoussant les canvas pour s’adapter aux limites rotéesColor.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
- Éviter les clips * : Settings
- Résultats opacés: passer un solide
Color
Au lieu deColor.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.
- Le fond transparent perdu*Sauver avec
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 = false
Le 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
- Optimiser les GIF animés dans .NET en utilisant Aspose.Imaging
- Optimiser les TIFF multi-page pour l'archivage dans .NET avec Aspose
- Animations à base de données dans .NET avec Aspose.Imaging
- Comparer Lossy vs. Lossless Image Compression dans .NET en utilisant Aspose.Imaging
- Compression d'image sans perte et déterminée de qualité dans .NET avec Aspose.Imaging