Görüntüleri şeffaf bir arka planla rastgele bir açıdan döndürmek, .NET’deki galeriler, çerçeveler ve tasarım araçları için sık görülen bir gerekliliktir. Aspose.Imaging for .Net bir görüntü yüklemek için doğrudan bir API sağlar, özelleştirilmiş bir köşede döngülür ve açıklığı destekleyen bir biçimde kaydedilir.

Tam örnek

// 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}");
                }
            }
        }
    }
}
  • Nasıl Çalışır *
  • Image.Load kaynağı açılır. kodu kontrol eder ve atar RasterImage Raster operasyonları için.
  • raster.Rotate(angle, expandCanvas, Color.Transparent) Her derece değerinde döndürülür.
  • kurtarma ile PngOptions Şeffaflığı korur.
  • Batch modu bir dizin ağacı yürür, desteklenen biçimleri döndürür ve PNG’ler yazar.

adım adım rehber

1) Görüntüyü yükle

Kullanımı Image.Load kaynak dosyasını açmak için.Cast to RasterImage İhtiyacınız varsa raster özel üyeler.

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

2) Her açıdan döndürme

Çağrı Rotate(angle, expandCanvas, backgroundColor).

  • angle derecelerinde
  • expandCanvas = true Yürüyen sınırlara uymak için kanvası yeniden döndürerek kaydırmaktan kaçının
  • Color.Transparent arka planı açık tutar, çıkış biçimi alfa’yı desteklerse
image.Rotate(17, true, Color.Transparent);

3) Şeffaflığı destekleyen bir biçimde kaydetmek

PNG şeffaflığı destekler. kullanımı PngOptions kaydedilen alfa kanalı ile döndürülen çıkış kaydetmek.

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

pratik seçenekler

  • Klip yapmaktan kaçının: set expandCanvas = true Sağ olmayan köşelerle döndüğünde
  • Opaque arka planlar: sağlam bir geçiş Color Bunun yerine Color.Transparent Doldurulmuş bir arka plan istiyorsanız
  • Kayıp çıkış: Kripto kenarları ve şeffaflık gerektiren UI, logolar ve yüzeyler için PNG’yi tercih edin
  • ** Fotoğrafçılık**: Eğer şeffaflığa ihtiyacınız yoksa, JPEG olarak tasarruf dosya boyutunu azaltabilir

Ortak pitfalls ve düzeltmeler

  • Gizli arka plan kaybolmuşkurtarma ile PngOptions veya alfa’yı destekleyen başka bir biçim. JPEG şeffaflığı desteklemez.

  • ** Görüntü parçaları dönüşten sonra kaybolur**Kullanımı expandCanvas = true Canvas’ı büyütmek, böylece döndürülen içerik uygun olur.

    • Dönüşümden Sonra Yürüyen Çerçeve*Eğer kaynağınız düşük çözünürlüğe sahipse, döndürmeden önce girişleri daha yüksek çözüme geri dönüştürmeyi düşünün, sonra görülebilir eserleri azaltmak için tasarruf ettikten sonra aşağı kaydırın.
    • Hafıza ve büyük resimler *Görüntüleri hızlı bir şekilde yerleştirin ve aynı anda birçok büyük dosyayı yüklemekten kaçının.

Mini kontrol listesi

  • Yükleme ile Image.Load
  • Rota ile image.Rotate(angle, true, Color.Transparent)
  • kurtarma ile new PngOptions() Şeffaflık için
  • Eğer şeffaflık gerekli değilse sağlam bir arka plan kullanın
  • Anahtar varlıklar için çıkışın görsel olarak doğrulanması

FAQ Hakkında

Hangi biçimler dönme sonrası şeffaflık tutarPNG ve diğer alfa kapasiteli biçimler. JPEG şeffaflığı korumaz.

  • Kanvası genişletmeden nasıl döndürürebilirim*Pass expandCanvas = falseOrijinal sınırların dışındaki içerik kaydedilecektir.

  • Her açıdan dönebilirim *Evet. açı parametresi herhangi bir sayı derecesi değerini kabul eder.

More in this category