Rysuj obrazy rastrowe i wektorowe

Niezależnie od tego, czy tworzysz stronę internetową, aplikację komputerową czy mobilną, możliwość manipulowania obrazami i rysowania na nich jest kluczowym aspektem podczas przetwarzania i edycji obrazów. Aby zapewnić programistom zaawansowane, a jednocześnie łatwe do wdrożenia funkcje rysowania, wprowadzamy [Aspose.Imaging.Drawing], potężny interfejs API przeznaczony dla aplikacji C# .NET, oferujący szereg funkcji rysowania obrazów.

Biblioteka rysunków C# .NET

Aspose.Imaging.Drawing to solidny interfejs API, który umożliwia przetwarzanie obrazów rastrowych i wektorowych przy użyciu zaawansowanych technik przetwarzania obrazu. Dzięki natywnemu dostępowi bajtowemu interfejs API zapewnia dużą prędkość przetwarzania podczas tworzenia lub manipulowania obrazami. Korzystając z interfejsu API, możesz rysować obiekty z manipulacją pikselami i ścieżką graficzną oraz konwertować obrazy z jednego formatu na inny. Aspose.Imaging.Drawing używa Aspose.Drawing jako domyślnego silnika graficznego, który jest wieloplatformową biblioteką grafiki 2D oferującą pełny zestaw funkcji do rysowania tekstu, geometrii i obrazów bez żadnych zewnętrznych zależności.

Możesz pobrać i zainstalować Aspose.Imaging.Drawing z NuGet.

PM> NuGet\Install-Package Aspose.Imaging.Drawing

Przyjrzyjmy się teraz niektórym istotnym funkcjom tego interfejsu API rysowania .NET i ich wykorzystaniu za pomocą kodu źródłowego.

Tworzenie grafiki przy użyciu biblioteki rysunków .NET

Aspose.Imaging.Drawing umożliwia tworzenie obrazów poprzez rysowanie różnych obiektów, takich jak okręgi, linie, trójkąty, kwadraty i elipsy. Nie tylko obrazy rastrowe, ale możesz generować obrazy wektorowe za pomocą API. Przyjrzyjmy się, jak rysować obrazy rastrowe i wektorowe w języku C# przy użyciu tego interfejsu API rysowania .NET.

Narysuj obraz rastrowy

Poniżej znajdują się kroki umożliwiające narysowanie obrazu rastrowego przy użyciu interfejsu API Aspose.Imaging.Drawing.

  • Najpierw utwórz obraz o żądanym formacie za pomocą metody Image.Create().
  • Następnie utwórz obiekt klasy Graphics i zainicjuj go za pomocą utworzonego powyżej obrazu Image.
  • Wyczyść powierzchnię obrazu metodą Graphics.Clear.
  • Utwórz nowy długopis i zainicjuj go żądanym kolorem.
  • Narysuj elipsę (lub dowolny inny obiekt graficzny) za pomocą metody Graphics.DrawEllipse().
  • Narysuj wielokąt za pomocą metody Graphics.FillPolygon().
  • Na koniec zapisz obraz za pomocą metody Image.Save().

Poniższy fragment kodu pokazuje, jak narysować obraz w języku C#.

string outputFolder = @"Output\";

// Utwórz instancję BmpOptions i ustaw jej różne właściwości
BmpOptions imageOptions = new BmpOptions();
imageOptions.BitsPerPixel = 24;

// Utwórz instancję FileCreateSource i przypisz ją do właściwości Source 
imageOptions.Source = new FileCreateSource(outputFolder + "result.bmp", false);

using (var image = Image.Create(imageOptions, 500, 500))
{
    var graphics = new Graphics(image);

    // Wyczyść powierzchnię obrazu kolorem białym, a następnie utwórz i zainicjuj obiekt Pióro kolorem niebieskim
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Blue);

    // Narysuj elipsę, definiując prostokąt ograniczający o szerokości 150 i wysokości 100. Narysuj także wielokąt za pomocą LinearGradientBrush
    graphics.DrawEllipse(pen, new Rectangle(10, 10, 150, 100));

    using (var linearGradientBrush = new LinearGradientBrush(image.Bounds, Color.Red, Color.White, 45f))
    {
        graphics.FillPolygon(linearGradientBrush, new[] { new Point(200, 200), new Point(400, 200), new Point(250, 350) });
    }

    // Zapisać obraz
    image.Save();
}

Narysuj obraz wektorowy

Podobnie jak w przypadku obrazów rastrowych, w kilku prostych krokach możesz narysować grafikę wektorową, taką jak SVG. Utwórzmy obraz wektorowy, korzystając z naszej biblioteki rysunków C#.

  • Najpierw utwórz obiekt MemoryStream.
  • Następnie załaduj obraz SVG.
  • Rasteryzuj plik SVG do formatu PNG i zapisz wynik w strumieniu.
  • Załaduj obraz PNG ze strumienia w celu dalszego rysowania.
  • Narysuj obraz PNG na istniejącym obrazie SVG.
  • Na koniec zapisz wyniki.

Poniższy fragment kodu pokazuje, jak narysować obraz wektorowy w języku C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (MemoryStream drawnImageStream = new MemoryStream())
{
    // Najpierw zrasteryzuj Svg do Png i zapisz wynik w strumieniu.
    using (SvgImage svgImage = (SvgImage)Image.Load(templatesFolder + "template.svg"))
    {
        SvgRasterizationOptions rasterizationOptions = new SvgRasterizationOptions();
        rasterizationOptions.PageSize = svgImage.Size;

        PngOptions saveOptions = new PngOptions();
        saveOptions.VectorRasterizationOptions = rasterizationOptions;

        svgImage.Save(drawnImageStream, saveOptions);

        // Teraz załaduj obraz PNG ze strumienia w celu dalszego rysowania.
        drawnImageStream.Seek(0, System.IO.SeekOrigin.Begin);
        using (RasterImage imageToDraw = (RasterImage)Image.Load(drawnImageStream))
        {
            // Czerpanie z istniejącego obrazu Svg.
            Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D graphics = new Aspose.Imaging.FileFormats.Svg.Graphics.SvgGraphics2D(svgImage);

            // Zmniejsz cały narysowany obraz 2 razy i narysuj go na środku powierzchni rysunkowej.
            int width = imageToDraw.Width / 2;
            int height = imageToDraw.Height / 2;
            Point origin = new Point((svgImage.Width - width) / 2, (svgImage.Height - height) / 2);
            Size size = new Size(width, height);

            graphics.DrawImage(imageToDraw, origin, size);

            // Zapisz obraz wynikowy
            using (SvgImage resultImage = graphics.EndRecording())
            {
                resultImage.Save(outputFolder + "vector_image.svg");
            }
        }
    }
}

Zastosuj maskowanie do obrazów

Maskowanie w edycji obrazu odnosi się do techniki selektywnego ukrywania lub ujawniania pewnych części obrazu. Polega na utworzeniu maski, która jest zasadniczo obrazem w skali szarości, który określa przezroczystość lub nieprzezroczystość każdego piksela na oryginalnym obrazie. Maskowanie obrazu jest szeroko stosowane w rozpoznawaniu i diagnostyce.

Aspose.Image.Drawing udostępnia dwie metody stosowania maskowania obrazu:

  • Maskowanie ręczne — wykorzystuje zestaw ROI jako maskę. Do zdefiniowania maski wykorzystywane są ROI dla każdego plasterka. Wymaga dodatkowego wkładu użytkownika.
  • Automatyczne maskowanie — nie wymaga od użytkownika dużej ilości danych wejściowych, ale może nie być tak dokładne.

Zobaczmy teraz, jak zastosować ręczne i automatyczne maskowanie obrazów w kodzie C#.

Ręczne maskowanie obrazu

Poniższy fragment kodu pokazuje, jak zastosować ręczne maskowanie obrazu w języku C#.

string outputFolder = @"Output\";

// Plik źródłowy
string sourceFileName = outputFolder + "couple.png";

// Utwórz ścieżkę graficzną
GraphicsPath manualMask = new GraphicsPath();

// Dodaj kształty
Figure firstFigure = new Figure();
firstFigure.AddShape(new EllipseShape(new RectangleF(100, 30, 40, 40)));
firstFigure.AddShape(new RectangleShape(new RectangleF(10, 200, 50, 30)));

// Dodaj figurę
manualMask.AddFigure(firstFigure);

GraphicsPath subPath = new GraphicsPath();
Figure secondFigure = new Figure();
secondFigure.AddShape(
    new PolygonShape(
     new PointF[]
     {
        new PointF(310, 100), new PointF(350, 200), new PointF(250, 200)

     }, true));

secondFigure.AddShape(new PieShape(new RectangleF(10, 10, 80, 80), 30, 120));
subPath.AddFigure(secondFigure);
manualMask.AddPath(subPath);

// Zastosuj maskowanie
using (RasterImage image = (RasterImage)Image.Load(sourceFileName))
{
    MaskingOptions maskingOptions = new MaskingOptions()
    {
        Method = SegmentationMethod.Manual,
        Args = new ManualMaskingArgs
        {
            Mask = manualMask
        },
        Decompose = false,
        ExportOptions =
      new PngOptions()
      {
          ColorType = PngColorType.TruecolorWithAlpha,
          Source = new StreamSource(new MemoryStream())
      },
    };
    MaskingResult results = new ImageMasking(image).Decompose(maskingOptions);
    // Zapisywanie końcowego wyniku maskowania.
    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "manual_masking.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Automatyczne maskowanie obrazu

Poniższy fragment kodu stosuje automatyczne maskowanie obrazu przy użyciu interfejsu API rysowania platformy .NET.

string outputFolder = @"Output\";

MaskingResult results;
using (RasterImage image = (RasterImage)Image.Load(outputFolder + "couple.jpg"))
{
    // Aby użyć Graph Cut z automatycznie obliczonymi pociągnięciami, używana jest opcja AutoMaskingGraphCutOptions.
    AutoMaskingGraphCutOptions options = new AutoMaskingGraphCutOptions
    {
        // Wskazanie, że podczas dekompozycji obrazu należy wykonać nowe obliczenie domyślnych pociągnięć.
        CalculateDefaultStrokes = true,
        
        // Ustawianie promienia wtapiania po procesie na podstawie rozmiaru obrazu.
        FeatheringRadius = (Math.Max(image.Width, image.Height) / 500) + 1,
        Method = SegmentationMethod.GraphCut,
        Decompose = false,
        ExportOptions =
            new PngOptions()
            {
                ColorType = PngColorType.TruecolorWithAlpha,
                Source = new FileCreateSource(outputFolder + "auto_masking.png")
            },
        BackgroundReplacementColor = Color.Transparent
    };

    results = new ImageMasking(image).Decompose(options);

    using (RasterImage resultImage = (RasterImage)results[1].GetImage())
    {
        resultImage.Save(outputFolder + "auto_masking_2.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
    }
}

Zastosuj filtry do obrazów

Stosowanie filtrów do obrazów służy różnym celom, a ludzie używają ich z różnych powodów, zarówno praktycznych, jak i artystycznych. Najczęstsze zastosowania filtrów obrazu obejmują korekcję kolorów, poprawę jakości obrazu, stosowanie efektów specjalnych, redukcję szumów i tak dalej. Aspose.Imaging.Drawing obsługuje kilka typów filtrów, które można zastosować do obrazów, takich jak mediana, Weiner ruchu, Weiner Gaussa itp.

W celu demonstracji spójrz na poniższy kod, który stosuje filtr mediany do obrazu za pomocą Aspose.Imaging.Drawing.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Załaduj zaszumiony obraz 
using (Image image = Image.Load(templatesFolder + "template.gif"))
{
    // Wrzuć obraz do RasterImage
    RasterImage rasterImage = image as RasterImage;
    if (rasterImage == null)
    {
        return;
    }

    // Utwórz instancję klasy MedianFilterOptions i ustaw rozmiar, zastosuj filtr MedianFilterOptions do obiektu RasterImage i zapisz wynikowy obraz
    MedianFilterOptions options = new MedianFilterOptions(4);
    rasterImage.Filter(image.Bounds, options);

    // Zapisać obraz
    image.Save(outputFolder + "median_filter.gif");
}

Przycinaj, obracaj i zmieniaj rozmiar obrazów

Przycinanie, obracanie i zmiana rozmiaru obrazów są uważane za podstawowe funkcje aplikacji do edycji obrazów. Są to najczęstsze operacje przetwarzania obrazu stosowane do manipulowania obrazami cyfrowymi. Przyjrzyjmy się, jak przycinać, obracać i zmieniać rozmiar obrazów za pomocą interfejsu API Aspose.Imaging.Drawing.

Przytnij obraz

Aby przyciąć obraz, musisz podać wartości przesunięcia dla wszystkich czterech stron obrazu. Na podstawie tych wartości granice obrazu są przesuwane w kierunku środka obrazu. Poniższy fragment kodu C# przycina obraz na podstawie podanych wartości przesunięcia.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Załaduj istniejący obraz do instancji klasy RasterImage
using (RasterImage rasterImage = (RasterImage)Image.Load(templatesFolder + "template.jpg"))
{
    // Przed przycięciem obraz powinien zostać zapisany w pamięci podręcznej w celu zapewnienia lepszej wydajności
    if (!rasterImage.IsCached)
    {
        rasterImage.CacheData();
    }

    // Zdefiniuj wartości przesunięcia dla wszystkich czterech stron
    int leftShift = 10;
    int rightShift = 10;
    int topShift = 10;
    int bottomShift = 10;

    // W oparciu o wartości przesunięcia zastosuj kadrowanie na obrazie Metoda kadrowania przesunie granice obrazu w kierunku środka obrazu i zapisze wyniki na dysku
    rasterImage.Crop(leftShift, rightShift, topShift, bottomShift);

    // Zapisz przycięty obraz
    rasterImage.Save(outputFolder + "cropped_image.jpg");
}

Obróć obraz

Aby obrócić obraz, Aspose.Imaging.Drawing udostępnia metodę RotateFlip, która nie tylko obraca obraz, ale także go odwraca (w razie potrzeby). Możesz wybrać żądaną opcję obracania i odwracania z wyliczenia RotateFlipType. Poniższy fragment kodu pokazuje, jak obrócić obraz, ale nie odwracać go w języku C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

// Ładowanie i obracanie obrazu
using (var image = Image.Load(templatesFolder + "template.jpg"))
{
    // Obróć obraz
    image.RotateFlip(RotateFlipType.Rotate270FlipNone);

    // Zapisać obraz
    image.Save(outputFolder + "rotated_image.jpg");
}

Zmień rozmiar obrazu

Zmiana rozmiaru obrazu za pomocą Aspose.Imaging.Drawing jest tak prosta, jak ciasto. Wystarczy wywołać metodę Resize i przekazać nowe wartości wysokości i szerokości. Poniższy fragment kodu pokazuje, jak zmienić rozmiar obrazu w języku C#.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (Image image = Image.Load(templatesFolder + "template.jpg"))
{
    // Zmiana rozmiaru obrazu
    image.Resize(300, 300);

    // Zapisać obraz
    image.Save(outputFolder + "resized_image.jpg");
}

Konwertuj obrazy na inne formaty

Aby przekonwertować obraz za pomocą interfejsu API Aspose.Imaging.Drawing, wystarczy załadować obraz i zapisać go w żądanym formacie wyjściowym. Poniższy fragment kodu konwertuje obraz JPG do formatów WebP, PSD, PDF i TIFF.

string templatesFolder = @"Templates\";
string outputFolder = @"Output\";

using (var img = Aspose.Imaging.Image.Load(templatesFolder + "template.jpg"))
{
    // Zapisz w różnych formatach obrazu
    img.Save(outputFolder + "output.webp", new Aspose.Imaging.ImageOptions.WebPOptions());
    img.Save(outputFolder + "output.psd ", new Aspose.Imaging.ImageOptions.PsdOptions());
    img.Save(outputFolder + "output.tiff", new Aspose.Imaging.ImageOptions.TiffOptions(TiffExpectedFormat.Default));

    // Zapisz jako plik PDF
    PdfOptions exportOptions = new PdfOptions();
    exportOptions.PdfDocumentInfo = new Aspose.Imaging.FileFormats.Pdf.PdfDocumentInfo();
    img.Save(outputFolder + "output.pdf", exportOptions);
}

Uzyskaj bezpłatną licencję API

Jeśli chcesz wypróbować interfejs API Aspose.Imaging.Drawing, możesz uzyskać bezpłatną tymczasową licencję, która pozwala na pełne wykorzystanie interfejsu API bez żadnych ograniczeń.

Wniosek

W dziedzinie grafiki i przetwarzania obrazów interfejs API Aspose.Imaging.Drawing wyróżnia się jako wszechstronne i potężne narzędzie dla programistów C# .NET. Niezależnie od tego, czy chcesz ulepszyć elementy wizualne, skorygować zniekształcenia obrazu, czy przekonwertować obrazy między formatami, ten interfejs API zapewnia kompleksowy zestaw funkcji. Dzięki Aspose.Imaging.Drawing manipulacja obrazami jest na wyciągnięcie ręki, umożliwiając programowe tworzenie fascynujących i oszałamiających wizualnie grafik.

Daj nam znać o swoich opiniach i pytaniach na naszym forum.