Class WebPImage

Class WebPImage

Nazwa przestrzeń: Aspose.Imaging.FileFormats.Webp Zgromadzenie: Aspose.Imaging.dll (25.4.0)

Manipuluj obrazami rasterów WebP z naszą API, korzystając z jej nowoczesnych funkcji dla obuBez strat i bez strat kompresja, zapewniając optymalną jakość obrazu przy zmniejszonych rozmiarach plików.Bezprzewodowo obsługiwać rozszerzone formaty plików, animacje i kanały alfa, podczas gdy łatwoaktualizacja wymiarów, proporcjonalnie rezygnacja, gromadzenie, obrotowanie, stosowanie filtracji,dostosowywanie parametrów obrazu i konwertowanie do innych formatów obrazów dla wszechstronnychOptymalizacja obrazu internetowego.

[JsonObject(MemberSerialization.OptIn)]
public sealed class WebPImage : RasterCachedMultipageImage, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadata, IMultipageImageExt, IMultipageImage

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage RasterCachedMultipageImage WebPImage

Implements

IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata , IMultipageImageExt , IMultipageImage

Dziedziczeni członkowie

RasterCachedMultipageImage.AdjustBrightness(int) , RasterCachedMultipageImage.AdjustContrast(float) , RasterCachedMultipageImage.AdjustGamma(float, float, float) , RasterCachedMultipageImage.AdjustGamma(float) , RasterCachedMultipageImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedMultipageImage.BinarizeFixed(byte) , RasterCachedMultipageImage.BinarizeBradley(double, int) , RasterCachedMultipageImage.BinarizeBradley(double) , RasterCachedMultipageImage.BinarizeOtsu() , RasterCachedMultipageImage.Crop(Rectangle) , RasterCachedMultipageImage.Crop(int, int, int, int) , RasterCachedMultipageImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedMultipageImage.Grayscale() , RasterCachedMultipageImage.NormalizeHistogram() , RasterCachedMultipageImage.Rotate(float, bool, Color) , RasterCachedMultipageImage.RotateFlip(RotateFlipType) , RasterCachedMultipageImage.RotateFlipAll(RotateFlipType) , RasterCachedMultipageImage.Resize(int, int, ResizeType) , RasterCachedMultipageImage.Resize(int, int, ImageResizeSettings) , RasterCachedMultipageImage.ResizeWidthProportionally(int, ResizeType) , RasterCachedMultipageImage.ResizeHeightProportionally(int, ResizeType) , RasterCachedMultipageImage.ReplaceColor(int, byte, int) , RasterCachedMultipageImage.ReplaceNonTransparentColors(int) , RasterCachedMultipageImage.Filter(Rectangle, FilterOptionsBase) , RasterCachedMultipageImage.NormalizeAngle(bool, Color) , RasterCachedMultipageImage.CacheData() , RasterCachedMultipageImage.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , RasterCachedMultipageImage.Height , RasterCachedMultipageImage.Width , RasterCachedMultipageImage.BitsPerPixel , RasterCachedMultipageImage.IsCached , RasterCachedMultipageImage.PageCount , RasterCachedMultipageImage.Pages , RasterCachedMultipageImage.HasAlpha , RasterCachedMultipageImage.HasTransparentColor , RasterCachedMultipageImage.ImageOpacity , RasterCachedMultipageImage.BackgroundColor , RasterCachedMultipageImage.XmpData , RasterCachedMultipageImage.PageExportingAction , RasterCachedImage.CacheData() , RasterCachedImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedImage.Resize(int, int, ResizeType) , RasterCachedImage.Resize(int, int, ImageResizeSettings) , RasterCachedImage.RotateFlip(RotateFlipType) , RasterCachedImage.Rotate(float, bool, Color) , RasterCachedImage.Crop(Rectangle) , RasterCachedImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedImage.Grayscale() , RasterCachedImage.NormalizeHistogram() , RasterCachedImage.BinarizeFixed(byte) , RasterCachedImage.BinarizeOtsu() , RasterCachedImage.BinarizeBradley(double, int) , RasterCachedImage.BinarizeBradley(double) , RasterCachedImage.AdjustBrightness(int) , RasterCachedImage.AdjustContrast(float) , RasterCachedImage.AdjustGamma(float, float, float) , RasterCachedImage.AdjustGamma(float) , RasterCachedImage.IsCached , RasterImage.RemoveMetadata() , RasterImage.Save(Stream, ImageOptionsBase, Rectangle) , RasterImage.GetModifyDate(bool) , RasterImage.Dither(DitheringMethod, int) , RasterImage.Dither(DitheringMethod, int, IColorPalette) , RasterImage.GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings) , RasterImage.GetDefaultArgb32Pixels(Rectangle) , RasterImage.GetDefaultRawData(Rectangle, RawDataSettings) , RasterImage.GetArgb32Pixel(int, int) , RasterImage.GetPixel(int, int) , RasterImage.SetArgb32Pixel(int, int, int) , RasterImage.SetPixel(int, int, Color) , RasterImage.ReadScanLine(int) , RasterImage.ReadArgb32ScanLine(int) , RasterImage.WriteScanLine(int, Color[]) , RasterImage.WriteArgb32ScanLine(int, int[]) , RasterImage.LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.LoadPartialPixels(Rectangle, IPartialPixelLoader) , RasterImage.LoadArgb32Pixels(Rectangle) , RasterImage.LoadArgb64Pixels(Rectangle) , RasterImage.LoadPartialArgb64Pixels(Rectangle, IPartialArgb64PixelLoader) , RasterImage.LoadPixels(Rectangle) , RasterImage.LoadCmykPixels(Rectangle) , RasterImage.LoadCmyk32Pixels(Rectangle) , RasterImage.LoadRawData(Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.LoadRawData(Rectangle, Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.SaveRawData(byte[], int, Rectangle, RawDataSettings) , RasterImage.SaveArgb32Pixels(Rectangle, int[]) , RasterImage.SavePixels(Rectangle, Color[]) , RasterImage.SaveCmykPixels(Rectangle, CmykColor[]) , RasterImage.SaveCmyk32Pixels(Rectangle, int[]) , RasterImage.SetResolution(double, double) , RasterImage.SetPalette(IColorPalette, bool) , RasterImage.Resize(int, int, ImageResizeSettings) , RasterImage.Rotate(float, bool, Color) , RasterImage.Rotate(float) , RasterImage.BinarizeFixed(byte) , RasterImage.BinarizeOtsu() , RasterImage.BinarizeBradley(double) , RasterImage.BinarizeBradley(double, int) , RasterImage.Blend(Point, RasterImage, Rectangle, byte) , RasterImage.Blend(Point, RasterImage, byte) , RasterImage.Grayscale() , RasterImage.NormalizeHistogram() , RasterImage.AdjustBrightness(int) , RasterImage.AdjustContrast(float) , RasterImage.AdjustGamma(float, float, float) , RasterImage.AdjustGamma(float) , RasterImage.GetSkewAngle() , RasterImage.NormalizeAngle() , RasterImage.NormalizeAngle(bool, Color) , RasterImage.Filter(Rectangle, FilterOptionsBase) , RasterImage.ReplaceColor(Color, byte, Color) , RasterImage.ReplaceColor(int, byte, int) , RasterImage.ReplaceNonTransparentColors(Color) , RasterImage.ReplaceNonTransparentColors(int) , RasterImage.ToBitmap() , RasterImage.PremultiplyComponents , RasterImage.UseRawData , RasterImage.UpdateXmpData , RasterImage.XmpData , RasterImage.RawIndexedColorConverter , RasterImage.RawCustomColorConverter , RasterImage.RawFallbackIndex , RasterImage.RawDataSettings , RasterImage.UsePalette , RasterImage.RawDataFormat , RasterImage.RawLineSize , RasterImage.IsRawDataAvailable , RasterImage.HorizontalResolution , RasterImage.VerticalResolution , RasterImage.HasTransparentColor , RasterImage.HasAlpha , RasterImage.TransparentColor , RasterImage.ImageOpacity , Image.CanLoad(string) , Image.CanLoad(string, LoadOptions) , Image.CanLoad(Stream) , Image.CanLoad(Stream, LoadOptions) , Image.Create(ImageOptionsBase, int, int) , Image.Create(Image[]) , Image.Create(MultipageCreateOptions) , Image.Create(string[], bool) , Image.Create(string[]) , Image.Create(Image[], bool) , Image.GetFileFormat(string) , Image.GetFileFormat(Stream) , Image.GetFittingRectangle(Rectangle, int, int) , Image.GetFittingRectangle(Rectangle, int[], int, int) , Image.Load(string, LoadOptions) , Image.Load(string) , Image.Load(Stream, LoadOptions) , Image.Load(Stream) , Image.GetProportionalWidth(int, int, int) , Image.GetProportionalHeight(int, int, int) , Image.RemoveMetadata() , Image.CanSave(ImageOptionsBase) , Image.Resize(int, int) , Image.Resize(int, int, ResizeType) , Image.Resize(int, int, ImageResizeSettings) , Image.GetDefaultOptions(object[]) , Image.GetOriginalOptions() , Image.ResizeWidthProportionally(int) , Image.ResizeHeightProportionally(int) , Image.ResizeWidthProportionally(int, ResizeType) , Image.ResizeHeightProportionally(int, ResizeType) , Image.ResizeWidthProportionally(int, ImageResizeSettings) , Image.ResizeHeightProportionally(int, ImageResizeSettings) , Image.RotateFlip(RotateFlipType) , Image.Rotate(float) , Image.Crop(Rectangle) , Image.Crop(int, int, int, int) , Image.Save() , Image.Save(string) , Image.Save(string, ImageOptionsBase) , Image.Save(string, ImageOptionsBase, Rectangle) , Image.Save(Stream, ImageOptionsBase) , Image.Save(Stream, ImageOptionsBase, Rectangle) , Image.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , Image.SetPalette(IColorPalette, bool) , Image.BitsPerPixel , Image.Bounds , Image.Container , Image.Height , Image.Palette , Image.UsePalette , Image.Size , Image.Width , Image.InterruptMonitor , Image.BufferSizeHint , Image.AutoAdjustPalette , Image.HasBackgroundColor , Image.FileFormat , Image.BackgroundColor , DataStreamSupporter.CacheData() , DataStreamSupporter.Save() , DataStreamSupporter.Save(Stream) , DataStreamSupporter.Save(string) , DataStreamSupporter.Save(string, bool) , DataStreamSupporter.DataStreamContainer , DataStreamSupporter.IsCached , DisposableObject.Dispose() , DisposableObject.Disposed , object.GetType() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

Ten przykład pokazuje, jak pobrać obraz WebP z pliku i zapisać go do PNG.

string dir = "c:\\temp\\";

                                                                                      // Load a WebP image from a file.
                                                                                      using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(dir + "test.webp"))
                                                                                      {
                                                                                          // Save to PNG
                                                                                          // Note that only the active frame will be stored to PNG, since PNG is not a multi-page format.
                                                                                          webPImage.Save(dir + "test.output.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                      }

Constructors

WebPimage(Stream)

Instancja nowej instancji klasy Aspose.Imaging.FileFormats.Webp. WebPImage, inicjalizowanaz dostarczonego źródła strumieniowego. Użyj tego konstruktora, aby bezproblemowo utworzyć WebPObiekty obrazu bezpośrednio z strumieni, umożliwiając efektywne zarządzanie i manipulacjęDane obrazowe WebP w Twojej aplikacji.

public WebPImage(Stream stream)

Parameters

stream Stream

Strumień obrazu WebP.

Examples

Ten przykład pokazuje, jak pobrać obraz WebP z przepływu plików i zapisać go do PNG.

string dir = "c:\\temp\\";

                                                                                             // Load a WebP image from a file stream.
                                                                                             using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "test.webp"))
                                                                                             using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(stream))
                                                                                             {
                                                                                                 // Save to PNG
                                                                                                 // Note that only the active frame will be stored to PNG, since PNG is not a multi-page format.
                                                                                                 webPImage.Save(dir + "test.output.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                             }

WebPimage(Strumień, LoadOptions)

Tworzenie nowej instancji klasy Aspose.Imaging.FileFormats.webp.WebPImage za pomocą przepływu iokreślone opcje ładowania, ułatwiające wszechstronne zarządzanie danymi obrazowymi WebP.Włącz ten konstruktor, aby bezwzględnie inicjalizować obiekty obrazu WebP zstrumieni podczas dostosowania parametrów ładowania zgodnie z wymaganiami w ramach aplikacji.

public WebPImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Strumień obrazu WebP.

loadOptions LoadOptions

Opcje opcji ładowania.

WebPimage(strumień)

Instancja nowej instancji klasy Aspose.Imaging.FileFormats.webp.WebPImage, inicjalizowanaz dostarczonego źródła pliku. Użyj tego konstruktora, aby bezproblemowo utworzyć WebPObiekty obrazu bezpośrednio z plików, ułatwiając proces ładowania iManipulacja danych obrazowych WebP w Twojej aplikacji.

public WebPImage(string path)

Parameters

path string

Ścieżka do pliku WebP Image

Examples

Ten przykład pokazuje, jak pobrać obraz WebP z pliku i zapisać go do PNG.

string dir = "c:\\temp\\";

                                                                                      // Load a WebP image from a file.
                                                                                      using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(dir + "test.webp"))
                                                                                      {
                                                                                          // Save to PNG
                                                                                          // Note that only the active frame will be stored to PNG, since PNG is not a multi-page format.
                                                                                          webPImage.Save(dir + "test.output.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                      }

WebPimage(String, Opcje ładowania)

Tworzenie nowej instancji klasy Aspose.Imaging.FileFormats.webp.WebPImage za pomocą pliku iokreślone opcje ładowania, ułatwiające elastyczną obsługę danych obrazowych WebP.Konstruktor ten bezwzględnie inicjalizuje obiekty obrazu WebP z plików podczasDostosowanie parametrów ładowania zgodnie z wymaganiami aplikacji.

public WebPImage(string path, LoadOptions loadOptions)

Parameters

path string

Ścieżka do pliku WebP Image

loadOptions LoadOptions

Opcje opcji ładowania.

WebPimage(RasterImage)

Instancja nowej instancji klasy Aspose.Imaging.FileFormats.Webp. WebPImage, inicjalizowanaz dostarczonego obiektu rasterImage. ten konstruktor umożliwia bezprzewodoweKonwersja obrazów rasterowych do formatu WebP, umożliwiając efektywną obsługę iManipulacja danych obrazowych w Twojej aplikacji.

public WebPImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

Wizerunek rasterów.

Examples

Ten przykład pokazuje, jak utworzyć obraz WebP z innego obrazu rastera.

string dir = "c:\\temp\\";

                                                                                   // Load a PNG image of 100x100 px.
                                                                                   using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                   {
                                                                                       Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                       // Fill the entire image in red.
                                                                                       Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                       graphics.FillRectangle(brush, pngImage.Bounds);

                                                                                       // Create a WebP image based on the PNG image.
                                                                                       using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(pngImage))
                                                                                       {
                                                                                           // Save to a WebP file with default options
                                                                                           webPImage.Save(dir + "output.webp", new Aspose.Imaging.ImageOptions.WebPOptions());
                                                                                       }
                                                                                   }

WebPimage(RasterImage i LoadOptions)

Tworzenie nowej instancji klasy Aspose.Imaging.FileFormats.webp.WebPimage za pomocą obiektu rasterImage iokreślone opcje ładowania, umożliwiające elastyczne zarządzanie danymi obrazowymi.Konstruktor bezwzględnie inicjalizuje obiekty obrazu WebP z obrazów rasterowych podczasDostosowanie parametrów ładowania zgodnie z wymaganiami aplikacji.

public WebPImage(RasterImage rasterImage, LoadOptions loadOptions)

Parameters

rasterImage RasterImage

Wizerunek rasterów.

loadOptions LoadOptions

Opcje opcji ładowania.

WebPimage(Int, Int i WebPoptions)

Zainstaluj nową instancję klasy Aspose.Imaging.FileFormats.Webp. WebPImage z pustymobraz określonej szerokości i wysokości wymiarów. ten konstruktor umożliwiatworzenie błyszczących obrazów WebP, zapewniając podstawę dla następnego obrazuManipulacja i generowanie treści w Twojej aplikacji.

public WebPImage(int width, int height, WebPOptions options)

Parameters

width int

Szerokość obrazu

height int

Wysokość obrazu.

options WebPOptions

i opcji .

Examples

Ten przykład pokazuje, jak utworzyć obraz WebP z określonymi opcjami z scratch.

string dir = "c:\\temp\\";

                                                                                                 Aspose.Imaging.ImageOptions.WebPOptions createOptions = new Aspose.Imaging.ImageOptions.WebPOptions();
                                                                                                 createOptions.Lossless = true;
                                                                                                 createOptions.Quality = 100f;
                                                                                                 //createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.webp");

                                                                                                 // Create a WebP image of 100x100 px.
                                                                                                 using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(100, 100, createOptions))
                                                                                                 {
                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(webPImage);

                                                                                                     // Fill the entire image in red.
                                                                                                     Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                     graphics.FillRectangle(brush, webPImage.Bounds);

                                                                                                     // Save to a WebP file
                                                                                                     webPImage.Save(dir + "output.webp");
                                                                                                 }

Ten przykład pokazuje, jak utworzyć multi-frame animowany obraz WebP z określonymi opcjami.

string dir = "c:\\temp\\";

                                                                                                         Aspose.Imaging.ImageOptions.WebPOptions createOptions = new Aspose.Imaging.ImageOptions.WebPOptions();
                                                                                                         createOptions.Lossless = true;
                                                                                                         createOptions.Quality = 100f;
                                                                                                         createOptions.AnimBackgroundColor = (uint)Aspose.Imaging.Color.Gray.ToArgb();

                                                                                                         // The default frame plus 36 + 36 additional frames.
                                                                                                         createOptions.AnimLoopCount = 36 + 36 + 1;

                                                                                                         // Create a WebP image of 100x100 px.
                                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(100, 100, createOptions))
                                                                                                         {
                                                                                                             // The first circle is red
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush1 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                             // The second circle is black
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush2 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Black);

                                                                                                             // Gradually inscrease the angle of the red arc shape.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);
                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(block);
                                                                                                                 graphics.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);

                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(block);
                                                                                                                 graphics.FillPie(brush2, block.Bounds, 0, angle);
                                                                                                                 graphics.FillPie(brush1, block.Bounds, angle, 360 - angle);

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Save to a WebP file
                                                                                                             webPImage.Save(dir + "output.webp");
                                                                                                         }

WebPimage(Int, int, WebPOptions, LoadOptions)

Tworzenie nowej instancji klasy Aspose.Imaging.FileFormats.webp.WebPimage z pustym obrazem i określonymOpcje ładowania. ten konstruktor umożliwia inicjalizację obrazów WebPdostosowane parametry ładowania, zapewniając elastyczność w tworzeniu obrazu iManipulacja w Twojej aplikacji.

public WebPImage(int width, int height, WebPOptions options, LoadOptions loadOptions)

Parameters

width int

Szerokość obrazu

height int

Wysokość obrazu.

options WebPOptions

i opcji .

loadOptions LoadOptions

Opcje opcji ładowania.

Properties

FileFormat

Dostęp do wartości formatu pliku powiązanego z obrazem, dostarczając informacjio formacie, w którym obraz jest przechowywany.Użyj tej właściwości, aby określićformat pliku obrazu, ułatwiając sprawdzenie zgodności iPrzetwarzanie formatu w Twojej aplikacji.

public override FileFormat FileFormat { get; }

Wartość nieruchomości

FileFormat

HasAlpha

Zwróć uwagę na to, czy obraz zawiera kanał alfa, wskazując obecnośćInformacje o przejrzystości.Użyj tej własności, aby ustalić, czy obrazobejmuje przejrzystość, umożliwiając odpowiednią obsługę i przetwarzanieOperacje związane z alfa w Twojej aplikacji.

public override bool HasAlpha { get; }

Wartość nieruchomości

bool

Examples

Poniższy przykład pobiera obraz WEBP i drukuje informacje na temat formatu surowych danych i kanału alfa.

string dir = "c:\\temp\\";

                                                                                                                   string fileName = dir + "sample.webp";
                                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
                                                                                                                   {
                                                                                                                       Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                                                       // If the active TIFF frame has alpha channel, then the entire TIFF image is considered to have alpha channel.
                                                                                                                       System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, webpImage.RawDataFormat, webpImage.HasAlpha);

                                                                                                                       int i = 0;
                                                                                                                       foreach (Aspose.Imaging.FileFormats.Webp.IFrame frame in webpImage.Blocks)
                                                                                                                       {
                                                                                                                           Aspose.Imaging.FileFormats.Webp.WebPFrameBlock frameBlock = frame as Aspose.Imaging.FileFormats.Webp.WebPFrameBlock;
                                                                                                                           if (frameBlock != null)
                                                                                                                           {
                                                                                                                               System.Console.WriteLine("Frame={0}, FileFormat={1}, HasAlpha={2}", i++, frameBlock.RawDataFormat, frameBlock.HasAlpha);
                                                                                                                           }
                                                                                                                       }
                                                                                                                   }

                                                                                                                   // The output may look like this:
                                                                                                                   // ImageFile=c:\temp\sample.webp, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False
                                                                                                                   // Frame=0, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False

Options

Odzyskiwanie lub modyfikacja opcji związanych z określonymi właściwościami, umożliwiającSposób dostosowywania zachowania i ustawień.Użyj tej właściwości dobezprzewodowy dostęp i manipulacja konfigurowalnych parametrów, ułatwiając wszechstronneKontrola i optymalizacja w ramach funkcjonalności aplikacji.

[JsonProperty]
public WebPOptions Options { get; }

Wartość nieruchomości

WebPOptions

PageCount

Przywróć całkowitą liczbę stron w określonym dokumencie, ułatwiającEfektywna nawigacja i zarządzanie treścią multi-page.funkcjonalności w celu poprawy doświadczenia użytkownika, umożliwiając bezprzewodowy dostęp dokompleksowe struktury dokumentów.

public override int PageCount { get; }

Wartość nieruchomości

int

Pages

Dostęp do bloków WebP wewnątrz obrazu, umożliwiając szczegółowe badanie lubmanipulacja podstawowej struktury bloku. użyj tej właściwości do analizylub modyfikować poszczególne bloki w danych obrazu WebP, ułatwiając zaawansowaneTechniki przetwarzania obrazu w Twojej aplikacji.

public override Image[] Pages { get; }

Wartość nieruchomości

Image [ ]

Methods

AddBlock(IFRAM)

Włącz nowy blok WebP do obrazu, wzbogacając jego zawartość iułatwia zaawansowaną manipulację obrazem. zintegrować tę metodę do dynamicznegopoprawia strukturę i złożoność danych obrazu WebP w Twoimaplikacji, umożliwiając dokładną kontrolę i optymalizację renderowania obrazu.

public void AddBlock(IFrame block)

Parameters

block IFrame

Blok Webp do dodania.

Examples

Ten przykład pokazuje, jak utworzyć multi-frame animowany obraz WebP z określonymi opcjami.

string dir = "c:\\temp\\";

                                                                                                         Aspose.Imaging.ImageOptions.WebPOptions createOptions = new Aspose.Imaging.ImageOptions.WebPOptions();
                                                                                                         createOptions.Lossless = true;
                                                                                                         createOptions.Quality = 100f;
                                                                                                         createOptions.AnimBackgroundColor = (uint)Aspose.Imaging.Color.Gray.ToArgb();

                                                                                                         // The default frame plus 36 + 36 additional frames.
                                                                                                         createOptions.AnimLoopCount = 36 + 36 + 1;

                                                                                                         // Create a WebP image of 100x100 px.
                                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(100, 100, createOptions))
                                                                                                         {
                                                                                                             // The first circle is red
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush1 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                             // The second circle is black
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush2 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Black);

                                                                                                             // Gradually inscrease the angle of the red arc shape.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);
                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(block);
                                                                                                                 graphics.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);

                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(block);
                                                                                                                 graphics.FillPie(brush2, block.Bounds, 0, angle);
                                                                                                                 graphics.FillPie(brush1, block.Bounds, angle, 360 - angle);

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Save to a WebP file
                                                                                                             webPImage.Save(dir + "output.webp");
                                                                                                         }

AddPage(RasterImage)

Dodaj nową stronę do obrazu, rozszerz jej treść i dopasuj dodatkoweIntegruj tę metodę, aby ułatwić dynamiczne zarządzanie stronamiw Twojej aplikacji, umożliwiając bezprzewodowe tworzenie i powiększenie wielu strondokumentów lub obrazów.

public void AddPage(RasterImage page)

Parameters

page RasterImage

Strona do dodania.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Wdrażaj dostosowanie jasności do obrazu, umożliwiając themodifikację ogólnych poziomów światła. Włącz tę metodę do twojego przepływu roboczego przetwarzania obrazów w celu zwiększenia widoczności i poprawy jakości wizualnej zdjęć w aplikacji.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Wartość jasności .

AdjustContrast(Floty)

Wzmacnia kontrast Aspose.Imaging.Image, powiększaróżnice między światłem a ciemnymi obszarami. integruj tę metodę do swojego obrazuPrzetwarzanie przepływów roboczych w celu poprawy jasności wizualnej i ogólnej jakości obrazu wTwoja aplikacja .

public override void AdjustContrast(float contrast)

Parameters

contrast float

Wartość kontrastu (w zakresie [-100; 100])

AdjustGamma(Floty)

Zastosuj korektę gamma do obrazu, dostosowując intensywność pikseli do osiągnięciaPożądana jasność i równowaga kolorów. Włącz tę metodę do swojego obrazuprzetwarzania przepływu roboczego w celu poprawy jakości wizualnej i poprawienia dokładnościNastępna analiza lub wyświetlanie zadań w Twojej aplikacji.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma dla współczynnika czerwonych, zielonych i niebieskich kanałów

AdjustGamma(float, float i float)

Wykonaj korektę gamma na obrazie za pomocą indywidualnych współczynników dla czerwonego,zielone i niebieskie kanały, umożliwiające dobrze dopasowane dostosowania równowagi kolorów iIntegruj tę metodę w twoją rurociągu przetwarzania obrazu, abydokładna kontrola renderowania kolorów i zwiększenie lojalności wizualnej w Twoimw aplikacji .

public override void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)

Parameters

gammaRed float

Gamma dla współczynnika czerwonego kanału

gammaGreen float

Gamma dla współczynnika zielonego kanału

gammaBlue float

Gamma dla współczynnika niebieskiego kanału

BinarizeBradley(podwójne, int)

Zastosuj binaryzację do obrazu za pomocą adaptowego algorytmu granicznego BradleyaZintegrowane granice obrazu. ta metoda dynamicznie oblicza lokalnegranice oparte na sąsiedztwie obrazu, zwiększając dostosowalność do różnychwarunki oświetlenia i zapewnienie solidnej segmentacji do późniejszej przetwarzaniaZadania w Twojej aplikacji.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Różnica jasności pomiędzy pikselem a przeciętnym oknem s x s pixelówWystarczy skupić się wokół tego piksela.

windowSize int

Rozmiar okna s x s pikseli skoncentrowane wokół tego piksela

BinarizeFixed(byte)

Wykonaj binaryzację obrazu za pomocą wstępnie zdefiniowanej wartości granicznej, konwertującw obrazie binarnym, w którym piksele są klasyfikowane jako przód lub tłow oparciu o ich intensywność względem granicy. integruj tę metodę wTwój przepływ roboczy przetwarzania obrazu ułatwia segmentację i ekstrakcję funkcjizadania, zwiększając dokładność i skuteczność dalszej analizy w Twoimw aplikacji .

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

W przypadku, gdy odpowiednia wartość szarowa piksela jest większa niż granica, wartości255 zostanie przydzielone do niego, 0 inaczej.

BinarizeOtsu()

Wykonaj binaryzację obrazu za pomocą metody granicznej Otsu, automatycznieokreślając optymalną wartość granicę w oparciu o histogram obrazu.ta metoda wchodzi do twojego przepływu roboczego przetwarzania obrazu w celu osiągnięcia skutecznej segmentacjii funkcja ekstrakcji, zwiększając dokładność i niezawodność analizy obrazuZadania w Twojej aplikacji.

public override void BinarizeOtsu()

ClearBlocks()

Wyczyścić wszystkie istniejące bloki WebP z obrazu, ułatwiając czysteNastępne modyfikacje lub dodatki. użyj tej metody, aby skutecznie ponownie ustawićstrukturę bloku w danych obrazowych WebP, zapewniając optymalne zarządzanie iOrganizacja treści obrazu w Twojej aplikacji.

public void ClearBlocks()

Crop(Rectangle)

Rośliny obrazu za pomocą określonego rektangularnego regionu, usuwając niepożądane porcjeprzy zachowaniu pożądanej zawartości. integruj tę metodę do swojego obrazuPrzetwarzanie przepływów roboczych w celu dokładnego wyciągania i skupienia się na konkretnych obszarach zainteresowaniawewnątrz obrazu, zwiększając jasność i kompozycję dla różnych aplikacji.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

z rektangulą .

Crop(Int, int, int, int, int)

Roślina obrazu poprzez zastosowanie lewego, prawnego, górnego i dolnego przesuwów, skuteczniewybieranie regionu zainteresowania w obrazie.Użyj tej metody dodynamicznie wyciągać pożądane części obrazu podczas dostosowania jego kompozycjii koncentruj się zgodnie z wymaganiami Twojej aplikacji.

public override void Crop(int leftShift, int rightShift, int topShift, int bottomShift)

Parameters

leftShift int

Po lewej zmianie.

rightShift int

Prawdziwa zmiana

topShift int

Najwyższa zmiana

bottomShift int

W dolnej zmianie.

Dither(DitheringMetoda, int, IColorPalette)

Wykonaj dystrybucję na bieżącym obrazie, aby zmniejszyć kolorowe powiązania i poprawić wzrokIntegruj tę metodę w przepływ pracy przetwarzania obrazu, abybardziej gładkie przejścia między kolorami i poprawiają ogólny wyglądZdjęcie w Twojej aplikacji.

public override void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)

Parameters

ditheringMethod DitheringMethod

Metoda dystrybucji .

bitsCount int

Ostatnie bity liczą na dystrybucję.

customPalette IColorPalette

Przygotowuje się paletę do Dithering.

Filter(Rectangle, FilterOptionsBase)

Filtrowanie treści w określonym rektanglu, stosując wyznaczony obrazfiltr przetwarzania w celu ulepszenia lub modyfikacji wybranego regionu.do przepływu roboczego manipulacji obrazu w celu osiągnięcia celowych ulepszeń lubZmiany w Twojej aplikacji.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

z rektangulą .

options FilterOptionsBase

i opcji .

Examples

Poniższy przykład stosuje różne rodzaje filtrów do obrazu WEBP.

string dir = "c:\\temp\\";

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a median filter with a rectangle size of 5 to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MedianFilterOptions(5));
                                                                                      webpImage.Save(dir + "sample.MedianFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a bilateral smoothing filter with a kernel size of 5 to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.BilateralSmoothingFilterOptions(5));
                                                                                      webpImage.Save(dir + "sample.BilateralSmoothingFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a Gaussian blur filter with a radius of 5 and a sigma value of 4.0 to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions(5, 4.0));
                                                                                      webpImage.Save(dir + "sample.GaussianBlurFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a Gauss-Wiener filter with a radius of 5 and a smooth value of 4.0 to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussWienerFilterOptions(5, 4.0));
                                                                                      webpImage.Save(dir + "sample.GaussWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a motion wiener filter with a length of 5, a smooth value of 4.0 and an angle of 90.0 degrees to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
                                                                                      webpImage.Save(dir + "sample.MotionWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a sharpen filter with a kernel size of 5 and a sigma value of 4.0 to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.SharpenFilterOptions(5, 4.0));
                                                                                      webpImage.Save(dir + "sample.SharpenFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

Grayscale()

Konwertuj obraz w jego grayscale, przekształcając go wobraz jednego kanału, w którym każdy piksel reprezentuje intensywność lub światłość.ta metoda w Twoim rurociągu przetwarzania obrazu, aby ułatwić analizę i poprawićkompatybilność z algorytmami opartymi na grayscale, ułatwiając różne komputeryZadanie wizji i analizy obrazu w Twojej aplikacji.

public override void Grayscale()

InsertBlock(Igrzyska, Iframe)

Wprowadź nowy blok WebP do określonego indeksu wewnątrz obrazu, umożliwiając dokładnośćkontrolę nad sekwencją bloku. Integruj tę metodę, aby bezwzględnie włączyćDodatkowe blokady WebP w strukturze danych obrazu, ułatwiając zaawansowane obrazyOpracowanie i optymalizacja w Twojej aplikacji.

public void InsertBlock(int index, IFrame block)

Parameters

index int

Element oparty na zero, w którym block’ zostanie umieszczony.

block IFrame

Blok Webp do dodania.

ReleaseManagedResources()

Uwolnij zarządzane zasoby. upewnij się, że nie są one uwalniane tutaj, ponieważ mogą byćJest już uwalniany.

protected override void ReleaseManagedResources()

RemoveBlock(IFRAM)

Usunąć określony blok WebP z obrazu, ułatwiając efektywne zarządzanieStruktura danych obrazu.Użyj tej metody, aby sprawnie przetwarzać obrazprzepływów pracy poprzez usunięcie niepotrzebnych bloków lub komponentów w Twojej aplikacji.

public void RemoveBlock(IFrame block)

Parameters

block IFrame

Blok do usunięcia.

Remarks

Uwaga: nie zapomnij umieścić blok " jeśli nie chcesz dodać go do innego WebPImage.

Resize(int, int, resizeType)

Odśwież obraz, dostosowując jego wymiary przy jednoczesnym zachowaniu stosunku aspektowego.Integruj tę metodę w przepływ pracy przetwarzania obrazu w celu dynamicznego skalowaniaZdjęcia do dostosowania do różnych wymagań wyświetlania lub przechowywania w Twojej aplikacji.

public override void Resize(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

resizeType ResizeType

Ten rodzaj rewizji.

Examples

Ten przykład ładuje obraz WEBP i odtwarza go przy użyciu różnych metod odświeżania.

string dir = "c:\\temp\\";

                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage image = (Aspose.Imaging.FileFormats.Webp.WebPImage)Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                         {
                                                                                             // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                             image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage image = (Aspose.Imaging.FileFormats.Webp.WebPImage)Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                         {
                                                                                             // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                             image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage image = (Aspose.Imaging.FileFormats.Webp.WebPImage)Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                         {
                                                                                             // Scale up by 2 times using Bilinear resampling.
                                                                                             image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage image = (Aspose.Imaging.FileFormats.Webp.WebPImage)Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                         {
                                                                                             // Scale down by 2 times using Bilinear resampling.
                                                                                             image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

Resize(int, int, ImageResizeSettings)

Recykling obrazu zgodnie z określonymi ustawieniami, umożliwiając dokładną kontrolę nadwymiary, stosunek aspektów i zachowanie skalowania. zintegrować tę metodę do swojegoprzepływ roboczy przetwarzania obrazu w celu osiągnięcia dostosowanych operacji odtworzeniaspecyficzne wymagania Twojej aplikacji.

public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

settings ImageResizeSettings

Zmiany w ustawieniach.

ResizeHeightProportionally(Tłumaczenie, ResizeType)

Dostosuj wysokość obrazu proporcjonalnie, zachowując jednocześnie jego stosunek aspektowyIntegruj tę metodę w procesie obrazudynamicznie odtwarzać obrazy w równomiernych proporcjach, zapewniając optymalny wyświetlacz lubprzechowywanie w Twojej aplikacji.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

Nowa wysokość .

resizeType ResizeType

Rodzaj rezygnacji.

ResizeWidthProportionally(Tłumaczenie, ResizeType)

Proporcjonalnie dostosować szerokość obrazu przy jednoczesnym utrzymaniu jego stosunku aspektowego.Integruj tę metodę w procesie obrazu, aby dynamicznie odtworzyćobrazy o spójnych proporcjach, zapewniając optymalne wyświetlanie lub przechowywanie wTwoja aplikacja .

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

Nowa szerokość .

resizeType ResizeType

Rodzaj rezygnacji.

Rotate(Float, Bool, Kolor)

Obrót obrazu wokół jego centrum przez określony kąt, podczas gdy proporcjonalnieodtwarzanie i zastosowanie określonych parametrów koloru tła.Metoda do przepływu roboczego przetwarzania obrazu w celu osiągnięcia dokładnych transformacjidostosowane kolory tła, zapewniając optymalną prezentację wizualną w Twoimw aplikacji .

public override void Rotate(float angle, bool resizeProportionally, Color backgroundColor)

Parameters

angle float

Kąt obrotowy w stopniach. wartości pozytywne będą obrotować zegarem.

resizeProportionally bool

Jeśli ustawisz na “prawdziwy”, zmienisz rozmiar obrazuw zależności od obrotowych projekcji rektangularnych (punktu węgielnego) w innym przypadku, które pozostawiają wymiary nie dotknięte i tylko wewnętrzne treści obrazów są obrotowane.

backgroundColor Color

Kolor z tła.

RotateFlip(RotateFlipType)

Zastosuj rotację, flipping lub obie operacje wyłącznie do aktywnego ramyIntegruj tę metodę w procesie obrazu dozapewnienie precyzyjnej manipulacji poszczególnych ram, zwiększenie elastyczności iKontrola transformacji ram w Twojej aplikacji.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Rodzaj rotacji flip.

SaveData(Stream)

Oszczędzaj dane.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Przepływ do przechowywania danych do.

UpdateDimensions(i int, int)

Aktualizacja wymiarów obrazu.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Nowy widok obrazu.

newHeight int

Nowa wysokość obrazu.

 Polski