Mengelilingi gambar dengan sudut yang sengaja dengan latar belakang yang transparan adalah persyaratan yang sering untuk galeri, dashboard, dan alat desain di .NET. Aspose.Imaging untuk .Net menyediakan API langsung untuk mengunggah gambar, mengelokasikan gambar dari sudutan yang disesuaikan dan menyimpannya ke format yang mendukung transparansi.

Contoh lengkap

// 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}");
                }
            }
        }
    }
}

Bagaimana cara kerja

  • Image.Load pembukaan sumber. kode memeriksa dan memasukkan ke RasterImage untuk operasi raster.
  • raster.Rotate(angle, expandCanvas, Color.Transparent) berputar pada setiap tingkat nilai.
  • Menjimatkan dengan PngOptions memelihara transparansi.
  • Mode batch berjalan pohon direktori, putar format yang didukung, dan menulis PNG.

Panduan Langkah-Langkah

1) Mengisi gambar

Penggunaan Image.Load untuk membuka file sumber.Cast untuk RasterImage Jika Anda membutuhkan anggota raster spesifik.

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

2) Bergerak dengan sudut apapun

panggilan Rotate(angle, expandCanvas, backgroundColor).

  • angle berada di tingkat
  • expandCanvas = true Menghindari klip dengan mengembalikan kanvas untuk menyesuaikan batas berputar
  • Color.Transparent menjaga latar belakang transparan jika format output mendukung alfa
image.Rotate(17, true, Color.Transparent);

3) Simpan ke format yang mendukung transparansi

PNG mendukung transparansi. menggunakan PngOptions untuk menyelamatkan output berputar dengan saluran alfa yang disimpan.

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

Pilihan praktis

  • *Menghindari pemadaman *: set expandCanvas = true Ketika berputar dengan sudut non-kanan
  • ** Latar Belakang Opak**: melewati solid Color Sebaliknya dari Color.Transparent Jika Anda ingin latar belakang yang penuh
  • ** output tanpa kerugian**: lebih suka PNG untuk UI, logo, dan overlays yang memerlukan sempadan dan transparansi
  • Photography: jika Anda tidak membutuhkan transparansi, simpan sebagai JPEG dapat mengurangi ukuran file

Tindakan dan Fix

    • Latar Belakang yang Hilang*menyelamatkan dengan PngOptions atau format lain yang mendukung alpha. JPEG tidak mendukung transparansi.

  • Bagian-bahagian gambar hilang setelah berputarPenggunaan expandCanvas = true Untuk membesarkan kanvas sehingga konten berputar sesuai.

  • Kedua-duanya ditutup setelah putaranRotasi menggunakan default perpustakaan.Jika sumber Anda resolusi rendah, pertimbangkan untuk mengembalikan input ke resolusinya yang lebih tinggi sebelum berputar, kemudian turun skala setelah menyimpan untuk mengurangi artefak yang terlihat.

    • Memori dan gambar besar*Menyediakan gambar dengan cepat dan menghindari muat banyak file besar sekaligus. mengkonfigurasi cakera caching untuk batch besar jika perlu.

Daftar Kecil

  • Mengisi dengan Image.Load
  • berputar dengan image.Rotate(angle, true, Color.Transparent)
  • menyelamatkan dengan new PngOptions() Untuk transparansi
  • Gunakan latar belakang yang solid jika transparansi tidak diperlukan
  • Validasi output secara visual untuk aset kunci

FAQ

  • Format mana yang tetap transparan setelah berputar*PNG dan format alpha-capable lainnya. JPEG tidak mempertahankan transparansi.

Bagaimana saya berputar tanpa memperbesar kanvasPass expandCanvas = falseKonten di luar batas-batas asli akan diklik.

  • Saya bisa berputar dari sudut mana pun*Parameter sudut menerima setiap nilai darjah numerik.

More in this category