V svete digitálneho umenia a fotografie, vytváranie vintage a umelecké efekty môže dýchať nový život do starých alebo priamych obrázkov. Aspose.Imaging pre .NET ponúka silný súbor nástrojov na dosiahnutie tohto, čo umožňuje vývojárom aplikovať rôzne techniky spracovania obrazu, ako je sepia tóny, rozmazanie, blurovanie, a ďalšie. Tento článok vás bude viesť cez proces aplikácie týchto efektov pomocou Asposa.Imaging, poskytuje podrobné kódy príklady a praktické tipy po ceste.

Kompletný príklad

Ak chcete začať, prejdeme do úplného príkladu, ktorý ukazuje, ako aplikovať viaceré efekty na obrázok v jednom kroku.Tento oddiel vás prechádza po celom procese od načítania obrazu, aby ste ho zachránili s požadovanými efektmi.

// File: Program.cs
// NuGet: Aspose.Imaging

using System;
using System.IO;
using Aspose.Imaging;
using Aspose.Imaging.ImageOptions;
using Aspose.Imaging.ImageFilters.FilterOptions;

namespace ArtisticEffectsDemo
{
    public static class Program
    {
        public static void Main(string[] args)
        {
            // Input and output
            var input  = args.Length > 0 ? args[0] : "input.jpg";
            var outDir = args.Length > 1 ? args[1] : "out";

            Directory.CreateDirectory(outDir);

            // Optional: enable disk cache for large images/batches
            // 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

            // 1) Sepia (pixel-based)
            using (var img = Image.Load(input))
            {
                var raster = img as RasterImage
                    ?? throw new InvalidOperationException("Not a raster image.");

                ApplySepiaInPlace(raster);
                raster.Save(Path.Combine(outDir, "sepia.png"), new PngOptions());
            }

            // 2) Gaussian blur (kernel filter)
            using (var img = Image.Load(input))
            {
                var raster = img as RasterImage
                    ?? throw new InvalidOperationException("Not a raster image.");

                // Kernel size must be an odd positive value. Sigma controls smoothing strength.
                var blur = new GaussianBlurFilterOptions(size: 5, sigma: 3.0);
                raster.Filter(raster.Bounds, blur);

                raster.Save(Path.Combine(outDir, "blur.png"), new PngOptions());
            }

            // 3) Emboss (convolution filter with custom kernel)
            using (var img = Image.Load(input))
            {
                var raster = img as RasterImage
                    ?? throw new InvalidOperationException("Not a raster image.");

                // A classic 3x3 emboss kernel that simulates light from top-left
                var kernel = new double[,]
                {
                    { -2, -1,  0 },
                    { -1,  1,  1 },
                    {  0,  1,  2 }
                };

                var emboss = new ConvolutionFilterOptions(kernel);
                raster.Filter(raster.Bounds, emboss);

                raster.Save(Path.Combine(outDir, "emboss.png"), new PngOptions());
            }

            Console.WriteLine("Effects created in: " + Path.GetFullPath(outDir));
        }

        /// <summary>
        /// In-place sepia conversion using standard coefficients.
        /// Works on the image pixel buffer for maximum control.
        /// </summary>
        private static void ApplySepiaInPlace(RasterImage raster)
        {
            // Load all pixels in one go
            var rect   = raster.Bounds;
            var pixels = raster.LoadPixels(rect);

            for (int i = 0; i < pixels.Length; i++)
            {
                var c = pixels[i];

                // Standard sepia transform (clamped to 0..255)
                double r = c.R;
                double g = c.G;
                double b = c.B;

                int tr = ClampToByte(0.393 * r + 0.769 * g + 0.189 * b);
                int tg = ClampToByte(0.349 * r + 0.686 * g + 0.168 * b);
                int tb = ClampToByte(0.272 * r + 0.534 * g + 0.131 * b);

                pixels[i] = Color.FromArgb(c.A, tr, tg, tb);
            }

            // Save pixels back
            raster.SavePixels(rect, pixels);
        }

        private static int ClampToByte(double x)
        {
            if (x < 0) return 0;
            if (x > 255) return 255;
            return (int)Math.Round(x);
        }
    }
}

Krok za krokom sprievodca

Krok 1: Nahrať obrázok

Prvým krokom je nahrať obrázok, ktorý chcete zmeniť. Aspose.Imaging poskytuje jednoduchú metódu pre toto:

Image image = Image.Load("path/to/your/image.jpg");

Krok 2: Využite efekt Sepia Tone

Sepia tón dáva obrazy starodávny vzhľad, pripomínajúci fotografie z začiatku 20. storočia. tu je, ako ju môžete aplikovať pomocou Aspose.Imaging:

// Apply Sepia Tone Effect
using (Image image = Image.Load("path/to/your/image.jpg"))
{
    image.Filter(new SepiaFilter());
}

Krok 3: Pridať Embossing pre textúru

Embossing pridáva do vášho obrazu trojrozmernú textúru, takže vyzerá ako keby bola vyrezaná alebo vyzdvihnutá z povrchu.

// Apply sepia tone effect to the image
using (SepiaFilter sepia = new SepiaFilter())
{
    sepia.Apply(image);
}

Krok 4: Blur obraz pre mäkkosť

Blurovanie obrazu môže zmierniť jeho okraje a znížiť hluk, čo mu dáva snívajúci vzhľad. Tu je spôsob, ako aplikovať Gaussian blur pomocou Aspose.Imaging:

// Apply embossing effect to create a textured appearance
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load("path/to/image.jpg"))
{
    Aspose.Imaging.Filters.FilterInfo embossFilter = new Aspose.Imaging.ImageFilters.FilterInfo(Aspose.Imaging.ImageFilters.FilterType.Emboss);
    image.Filter(embossFilter);
}

Krok 5: Uložiť zmenený obrázok

Po aplikácii všetkých požadovaných efektov, uložiť upravený obrázok na váš disk alebo akékoľvek umiestnenie ukladania podľa vášho výberu:

image.Save("path/to/save/modified_image.jpg", new JpegOptions());

Najlepšie postupy

Pri práci s efektmi obrazu v Aspose.Imaging pre .NET je dôležité zvážiť následky výkonu aplikácie viacerých efektov.Každý efekt môže byť zdrojovo intenzívny, takže je dobré dôkladne testovať aplikáciu a optimalizovať, ak je to potrebné.

Okrem toho experimentovanie s rôznymi kombináciami efektov môže viesť k jedinečným a kreatívnym výsledkom.Nebojte sa preskúmať mimo príkladov tu a objavovať nové spôsoby, ako zlepšiť vaše obrazy.

S nasledovaním tohto sprievodcu by ste mali teraz mať pevnú základňu na vytvorenie vintage a umeleckých efektov na snímkach pomocou Aspose.Imaging pre .NET.

More in this category