A digitális művészet és a fotózás világában a vintage és művészeti hatások létrehozása új életet adhat a régi vagy tiszta képekbe.Aspose.Imaging for .NET hatalmas eszközökkel rendelkezik, amelyek lehetővé teszik a fejlesztők számára, hogy különböző képfeldolgozási technikákat alkalmazzanak, mint például a sepia hangok, az embossing, a blurring és így tovább.Ez a cikk útmutatást nyújt Önnek ezeket a hatásokat az Aspose használatával, részletes kódmintákat és gyakorlati tippeket biztosít az úton.

Teljes példa

Ahhoz, hogy elkezdjük, merüljünk át egy teljes példa, amely azt mutatja, hogyan kell alkalmazni több hatást egy kép egy lépésben. Ez a szakasz megy keresztül az egész folyamatot a feltöltés a kép menteni azt a kívánt hatások alkalmazott.

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

lépésről lépésre útmutató

1. lépés: töltse fel a képet

Az első lépés az, hogy töltse fel a képet, amit szeretne módosítani. Aspose.Imaging biztosítja egy egyszerű módszert erre:

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

2. lépés: A Sepia Tone Effect alkalmazása

Sepia tónus ad a képek egy ősi stílusú megjelenés, emlékeztet a fényképek a 20. század elején. Íme, hogyan lehet alkalmazni az Aspose.Imaging:

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

3. lépés: Add Embossing for Texture

Az embossing háromdimenziós textúrát ad a képhez, így úgy néz ki, mintha a felszínről készült volna vagy felemelkedett volna.

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

4. lépés: Blur a képet a puha

Az ábrázolás enyhítheti a szélét és csökkenti a zajt, ami álmodó megjelenést ad. Íme, hogyan kell alkalmazni egy Gaussian blur használatával 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);
}

5. lépés: mentse meg a módosított képet

Miután az összes kívánt hatást alkalmazta, mentse meg a módosított képet a lemezre vagy bármely a választott tárolási helyre:

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

Legjobb gyakorlatok

A képhatásokkal dolgozva a .NET számára fontos figyelembe venni a többszörös hatások alkalmazásának teljesítménykövetelményeit.Minden hatás erőforrás-intenzív lehet, ezért jó ötlet az alkalmazás alaposan tesztelésére és optimalizálására, ha szükséges.

Ezenkívül a különböző hatáskombinációkkal való kísérletezés egyedülálló és kreatív eredményeket eredményezhet. Ne habozzon felfedezni az itt bemutatott példákat és új módszereket találni a képek javítására.

Ezt az útmutatót követve most szilárd alapot kell kapnia a vintage és művészi hatások létrehozására a képeken az Aspose.Imaging .NET.

More in this category