Digitaalisen taiteen ja valokuvauksen maailmassa vintage- ja taiteellisten vaikutusten luominen voi hengittää uutta elämää vanhoihin tai tasaisiin kuvia. Aspose.Imaging for .NET tarjoaa tehokkaan työkalujen joukon saavuttaa tämä, jonka avulla kehittäjät voivat soveltaa erilaisia kuvankäsittelytekniikoita, kuten sepia sävyjä, valaistaminen, värjäys, ja enemmän. Tämä artikkeli ohjaa sinua läpi prosessin soveltamisesta näitä vaikutuksia käyttämällä Asposa.Imaging, joka tarjoaa yksityiskohtaisia koodin esimerkkejä ja käytännön vinkkejä tiellä.

Täydellinen esimerkki

Aloittaaksemme, pohtimme täydellistä esimerkkiä, joka osoittaa, miten soveltaa useita vaikutuksia kuvalle yhdellä kierroksella.Tämä osa kulkee läpi koko prosessin kuvan lataamisesta sen säästämiseen toivottujen vaikutusten kanssa.

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

Vaiheittainen opas

Vaihe 1: Lataa kuva

Ensimmäinen askel on ladata kuva, jonka haluat muuttaa. Aspose.Imaging tarjoaa yksinkertaisen menetelmän tähän:

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

Vaihe 2: Soveltaa Sepia Tone Effect

Sepia-toni antaa kuviin vanhan muodin ulkonäkö, joka muistuttaa 2000-luvun alusta tulevia valokuvia. Tässä on, miten sitä voidaan soveltaa Aspose.Imaging:

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

Vaihe 3: Lisää Embossing tekstiin

Embossing lisää kuvan kolmiulotteisen teksturin, joten se näyttää siltä, että se on maalattu tai nostettu pinnalta.Tämä vaikutus voidaan saavuttaa seuraavalla koodilevyllä:

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

Vaihe 4: Blur kuvan pehmeyttä varten

Kuvan puristaminen voi lievittää sen reunoja ja vähentää melua, mikä antaa sille unelmoivan ulkonäön. Tässä on, miten soveltaa Gaussin puristus käyttämällä 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);
}

Vaihe 5: Tallenna muokattu kuva

Kun olet soveltanut kaikki halutut vaikutukset, tallentaa muokattu kuva levylle tai minkä tahansa valintasi tallennuspaikka:

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

Parhaat käytännöt

Kun työskentelet kuvan vaikutusten kanssa Aspose.Imaging for .NET, on tärkeää harkita suorituskyvyn seurauksia soveltaa useita vaikutuksia. Jokainen vaikutus voi olla resurssien intensiivinen, joten se on hyvä idea testata sovelluksesi perusteellisesti ja optimoida tarvittaessa.

Lisäksi erilaisten vaikutusten yhdistelmien kokeileminen voi johtaa ainutlaatuisiin ja luovisiin tuloksiin. Älä epäröi tutkia tässä esitettyjä esimerkkejä ja löytää uusia tapoja parantaa kuvia.

Tämän oppaan noudattamalla sinun pitäisi nyt olla vankka perusta vintage- ja taiteellisten vaikutusten luomiseen kuvia käyttämällä Aspose.Imaging for .NET.

More in this category