Class WebPImage

Class WebPImage

Název místa: Aspose.Imaging.FileFormats.Webp Shromáždění: Aspose.Imaging.dll (25.4.0)

Manipulovat snímky webp raster s naším API, pomocí jeho moderních funkcí pro obabez ztrát a bez ztrát komprese, která zajišťuje optimální kvalitu obrazu s omezenými velikostmi soubor.Bezprostředně zvládnout rozšířené formáty souborů, animace a alfa kanály, zatímco snadnoaktualizace rozměrů, přiměřené resing, hromadění, otáčení, aplikace filtr,přizpůsobení parametrů obrazu a konverze do jiných formátů obrazu pro všestrannéWebová optimalizace obrazu.

[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

Dědiční členové

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

Tento příklad ukazuje, jak načítat obrázek WebP z souboru a uložit ho 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)

Instantiate nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage, inicializovanéz poskytnutého zdroje toku. Použijte tento konstruktér k bezproblémovému vytváření WebPObjekty obrazu přímo z proudů, které umožňují efektivní manipulaci a manipulaciWebP image data v rámci vaší aplikace.

public WebPImage(Stream stream)

Parameters

stream Stream

Obrazový stream WebP.

Examples

Tento příklad ukazuje, jak načítat obrázek WebP z souborového toku a uložit ho 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(Přenos, LoadOptions)

Vytvořte nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage pomocí toku aspecifikované možnosti nabíjení, které usnadňují všestrannou manipulaci s webovými obrázky.Integrujte tento konstruktor k bezvýhradně iniciovat WebP image objekty zstreamování při přizpůsobení nabíjecích parametrů podle potřeby ve vaší aplikaci.

public WebPImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Obrazový stream WebP.

loadOptions LoadOptions

Možnosti nabíjen.

WebPimage(Stringová)

Instantiate nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage, inicializovanéz poskytnutého zdroje souborů. Použijte tento konstruktér k bezproblémovému vytváření WebPObjekty obrazu přímo z souborů, zjednodušující proces nabití aManipulace s webovými obrázky ve vaší aplikaci.

public WebPImage(string path)

Parameters

path string

Cesta k souboru WebP Image

Examples

Tento příklad ukazuje, jak načítat obrázek WebP z souboru a uložit ho 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 a LoadOptions)

Vytvořte nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage pomocí souboru aspecifikované možnosti nabíjení, které usnadňují flexibilní zpracování údajů o obraze WebP.Tento konstruktor bezproblémově iniciovat WebP image objekty z souborů, zatímcoPřizpůsobte parametry nabíjení podle požadavků vaší aplikace.

public WebPImage(string path, LoadOptions loadOptions)

Parameters

path string

Cesta k souboru WebP Image

loadOptions LoadOptions

Možnosti nabíjen.

WebPimage(RasterImage)

Instantiate nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage, inicializovanéz předloženého rasterImage objekt. Tento konstruktor umožňuje bezdrátovékonverze rasterových snímků do formátu WebP, což umožňuje efektivní zpracování amanipulace s informacemi o obraze v rámci vaší aplikace.

public WebPImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

Snímek z rastu.

Examples

Tento příklad ukazuje, jak vytvořit obrázek WebP z jiného obrázku rastu.

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(Rozhraní, LoadOptions)

Vytvořte nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage pomocí objektu rasterImage aspecifikované možnosti nabíjení, které umožňují flexibilní zpracování údajů o obraze.konstruktér k bezvýhradně inicializovat WebP image objekty z raster obrázků přiPřizpůsobte parametry nabíjení podle požadavků vaší aplikace.

public WebPImage(RasterImage rasterImage, LoadOptions loadOptions)

Parameters

rasterImage RasterImage

Snímek z rastu.

loadOptions LoadOptions

Možnosti nabíjen.

WebPimage(Int, Int a WebPoptions)

Instantujte nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPimage s prázdnouobrázek specifikované šířky a výšky rozměrů.Tento konstruktor umožňujevytváření bílých WebP obrázků, které poskytují základy pro následný obrázekManipulace a generace obsahu v rámci vaší aplikace.

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

Parameters

width int

Rozsah obrazu

height int

Výška obrazu.

options WebPOptions

Tyto možnosti.

Examples

Tento příklad ukazuje, jak vytvořit webp obrázek s uvedenými možnostmi z skratku.

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

Tento příklad ukazuje, jak vytvořit multi-frame animovaný WebP obrázek s uvedenými možnostmi.

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)

Vytvořte nový příklad třídy Aspose.Imaging.FileFormats.Webp.WebPImage s prázdným obrázkem a specifikovanýmNabíjení možností.Tento konstruktor umožňuje zahájení WebP obrázků spřizpůsobitelné parametry nabíjení, které poskytují flexibilitu při vytváření obrazu aManipulace v rámci vaší aplikace.

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

Parameters

width int

Rozsah obrazu

height int

Výška obrazu.

options WebPOptions

Tyto možnosti.

loadOptions LoadOptions

Možnosti nabíjen.

Properties

FileFormat

Přístup k hodnotě formátu souboru spojené s obrázkem, poskytuje informaceo formátu, ve kterém je obrázek uložen. Použijte tuto vlastnost k určeníformát souboru obrazu, který usnadňuje ověření kompatibility aFormátové zpracování ve vaší aplikaci.

public override FileFormat FileFormat { get; }

Hodnota nemovitosti

FileFormat

HasAlpha

Zjistěte, zda obrázek obsahuje alfa kanál, který naznačuje přítomnostinformace o transparentnosti. Použijte tuto vlastnost k určení, zda je obrazzahrnuje transparentnost, která umožňuje odpovídající zpracování a zpracováníAlfa související operace v rámci vaší aplikace.

public override bool HasAlpha { get; }

Hodnota nemovitosti

bool

Examples

Následující příklad nahrává obrázek WEBP a vytiskne informace o formátu surových dat a alfa kanálu.

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

Zrušit nebo změnit možnosti spojené s uvedeným majetkem, které umožňujípřizpůsobení chování a nastavení. Použijte tuto vlastnost kbezproblémový přístup a manipulace konfigurovatelných parametrů, usnadňující všestrannéKontrola a optimalizace v rámci funkce aplikace.

[JsonProperty]
public WebPOptions Options { get; }

Hodnota nemovitosti

WebPOptions

PageCount

Odstranit celkový počet stránek v uvedeném dokumentu, usnadnitefektivní navigace a řízení obsahu na více stránkách.funkčnost ke zlepšení uživatelské zkušenosti, umožňující bezproblémový přístup kkomplexní dokumentační struktury.

public override int PageCount { get; }

Hodnota nemovitosti

int

Pages

Přístup k blokům WebP v rámci obrazu, což umožňuje podrobné zkoumání nebomanipulace podkladové struktury bloků. Použijte tuto vlastnost k analýzenebo měnit jednotlivé bloky v rámci dat obrázku WebP, usnadňující pokročiléTechnika zpracování obrazu v rámci vaší aplikace.

public override Image[] Pages { get; }

Hodnota nemovitosti

Image []a[]

Methods

AddBlock(Ifrám)

Integrujte nový blok WebP do obrazu, obohacením jeho obsahu aUmožňuje pokročilou manipulaci s obrazem. integrovat tuto metodu do dynamickéhoZlepšuje strukturu a složitost dat snímku WebP ve vašemaplikace, která umožňuje přesnou kontrolu a optimalizaci renderování obrazu.

public void AddBlock(IFrame block)

Parameters

block IFrame

Webp blok pro přidán.

Examples

Tento příklad ukazuje, jak vytvořit multi-frame animovaný WebP obrázek s uvedenými možnostmi.

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)

Připojte novou stránku k obrázku, rozšířte jeho obsah a ubytujte dalšíIntegrujte tuto metodu, abyste usnadnili dynamickou správu stránekv rámci vaší aplikace, umožňující bezproblémové vytváření a rozšíření více stránekDokumenty nebo obrázky.

public void AddPage(RasterImage page)

Parameters

page RasterImage

Stránka k přidán.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Implement brightness’ adjustment for the image, allowing themodification of overall luminance levels.Incorporate this method into your image processing workflow to improve visibility and improve the visual quality of imageswithin your application.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Světelná hodnota.

AdjustContrast(flotila)

Zlepšuje kontrast Aspose.Imaging.Image, zesilujerozdíly mezi světlem a tmavou oblastí.Integrujte tuto metodu do vašeho obrazuzpracování pracovního toku s cílem zlepšit vizuální jasnost a celkovou kvalitu obrazu v rámciVaše žádost.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Kontrastní hodnota (v rozmezí [-100; 100])

AdjustGamma(flotila)

Aplikujte gamma korekci na obrázek, přizpůsobením intenzity pixelů k dosaženípožadovaný jas a barva rovnováha. začlenit tuto metodu do vašeho obrazuzpracování pracovního toku s cílem zlepšit vizuální kvalitu a zlepšit přesnostnásledné analýzy nebo zobrazení úkolů v rámci vaší aplikace.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Koeficient pro červené, zelené a modré kanály

AdjustGamma(plavba, plavba, plavba)

Výkon gamma korekce na obrázku pomocí jednotlivých koeficientů pro červenou,zelené a modré kanály, které umožňují jemně tónované úpravy barevné rovnováhy aIntegrujte tuto metodu do vašeho potrubí pro zpracování obrazu, abyste dosáhliPřesná kontrola barevného renderování a zvýšení vizuální věrnosti uvnitřAplikace.

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

Parameters

gammaRed float

Gamma pro koeficient červeného kanálu

gammaGreen float

Gamma pro koeficient zeleného kanálu

gammaBlue float

Gamma pro koeficient modrého kanálu

BinarizeBradley(Dvojnásobný, int)

Aplikujte binarizaci na obrázek pomocí Bradleyho adaptivního prahu algoritmus integrovaným hranicí obrazu. tato metoda dynamicky počítá lokálníhranici založené na sousedství obrazu, zvyšující přizpůsobivost různýmpodmínky osvětlení a zajištění robustní segmentace pro následné zpracováníkoly v rámci Vaší žádosti.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Rozdíl v jasu mezi pixelem a průměrem okna s x s pixelůSkládá se kolem tohoto pixelu.

windowSize int

Velikost okna s x s pixely soustředěné kolem tohoto pixelu

BinarizeFixed(byte)

Výkon binaryzace na obrázku pomocí předdefinované prahové hodnoty, konverzido binárního obrazu, kde jsou pixely klasifikovány jako přední nebo pozadína základě jejich intenzity ve vztahu k prahu. integrovat tuto metodu doVáš pracovní tok zpracování obrazu usnadňuje segmentování a extrakci funkcíúkoly, které zvyšují přesnost a účinnost následné analýzy v rámci vašehoAplikace.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Pokud odpovídající šedá hodnota pixelů je větší než hranici, hodnota255 bude k němu přiděleno, 0 jinak.

BinarizeOtsu()

Výkon binaryzace na obrázku pomocí tržní metody Otsu, automatickystanovení optimální prahové hodnoty na základě histogramu obrazu.tato metoda do vašeho pracovního toku zpracování obrazu k dosažení efektivní segmentacea funkční extrakce, která zvyšuje přesnost a spolehlivost analýzy obrazukoly v rámci Vaší žádosti.

public override void BinarizeOtsu()

ClearBlocks()

Odstraňte všechny existující WebP bloky z obrazu, čímž se usnadní čistánásledné změny nebo doplňky. Použijte tuto metodu k účinnému resetovánístrukturu bloků v rámci údajů o obraze WebP, které zajišťují optimální správu aOrganizace obsahu obrazu v rámci vaší aplikace.

public void ClearBlocks()

Crop(Rectangle)

Pěstujte obrázek pomocí určité rektangulární oblasti, odstraněním nežádoucích porcípři zachování požadovaného obsahu. integrovat tuto metodu do vašeho obrazuzpracování pracovního toku s cílem přesně extrahovat a soustředit se na konkrétní oblasti zájmuv rámci obrazu, zvyšuje jasnost a složení pro různé aplikace.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

V pravém úhlu.

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

Výroba obrazu aplikací levých, pravých, horních a dolních směn, efektivněvybrat oblast zájmu v obrazu. Použijte tuto metodu prodynamicky extrahovat požadované části obrazu při úpravě jeho složenía soustředit se podle požadavků vaší aplikace.

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

Parameters

leftShift int

Vlevo se měn.

rightShift int

Na správnou změnu.

topShift int

V horním směru.

bottomShift int

V dolním směru.

Dither(DitheringMetoda, int, IColorPalette)

Provádějte dyting na aktuálním obrázku, abyste snížili barevné vazby a zlepšili vizuálníIntegrujte tuto metodu do vašeho pracovního toku zpracování obrazu, abyste dosáhlihladší přechody mezi barvami a zlepšuje celkový vzhledobrázek ve vaší aplikaci.

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

Parameters

ditheringMethod DitheringMethod

Způsob rozptýlen.

bitsCount int

Poslední bity počítají na dithering.

customPalette IColorPalette

Závěrečná paleta pro dytován.

Filter(Rektangle, FilterOptionsBase)

Filtrovat obsah v uvedeném pravém rohu, aplikovat určený obrázekzpracování filtru ke zlepšení nebo změně vybraného regionu.do vašeho pracovního toku manipulace s obrazem k dosažení cílených vylepšení neboTransformace ve vaší aplikaci.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

V pravém úhlu.

options FilterOptionsBase

Tyto možnosti.

Examples

Následující příklad se vztahuje na různé typy filtrů na obrázek 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()

Přeměňte obrázek na jeho grayscale reprezentace, přeměňte ho naJednorázový obraz, ve kterém každý pixel představuje intenzitu nebo osvětlení.Tato metoda do vašeho obrazu zpracování potrubí zjednodušit analýzu a zlepšitkompatibilita s grayscale-based algoritmy, usnadňující různé počítačeVize a analýza obrazu úkoly ve vaší aplikaci.

public override void Grayscale()

InsertBlock(Ifrám, Ifrám)

Vložte nový blok WebP na specifikovaném indexu v obrazu, což umožňuje přesnostovládání nad sekvencí bloků. Integrujte tuto metodu tak, aby sedalší WebP bloky do struktury dat obrazu, které usnadňují pokročilé snímkyzpracování a optimalizace v rámci vaší aplikace.

public void InsertBlock(int index, IFrame block)

Parameters

index int

Nulový prvek, ve kterém bude block’ vložen.

block IFrame

Webp blok pro přidán.

ReleaseManagedResources()

Uvolňuje spravované zdroje. ujistěte se, že zde nejsou zveřejněny žádné nezveřejněné zdroje, protože mohou býtUž byl propuštěn.

protected override void ReleaseManagedResources()

RemoveBlock(Ifrám)

Odstraňte specifikovaný blok WebP z obrazu, což usnadňuje efektivní řízeníVyužijte tuto metodu k zjednodušení zpracování obrazupracovní toky odstraněním zbytečných bloků nebo komponent v rámci vaší aplikace.

public void RemoveBlock(IFrame block)

Parameters

block IFrame

Blok na odstraněn.

Remarks

Poznámka: nezapomeňte nastavit blok , pokud ho nechcete přidat do jiného WebPImage.

Resize(int, int, resizeType)

Obnovte obrázek, upravte jeho rozměry a zároveň zachováváte poměr vzhledu.Integrujte tuto metodu do vašeho pracovního toku zpracování obrazu, abyste se dynamicky rozšiřovalisnímky, které odpovídají různým požadavkům zobrazení nebo ukládání v rámci aplikace.

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

Parameters

newWidth int

A nová šířka.

newHeight int

A nová výška.

resizeType ResizeType

Tyto typy jsou recidivn.

Examples

Tento příklad nahrává obrázek WEBP a recykluje ho pomocí různých recyklovacích metod.

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(snímky, snímky, snímky)

Obnovte obrázek podle stanovených nastavení, což umožňuje přesnou kontrolu nadrozměry, poměr aspektů a skalování chování. integrovat tuto metodu do vašehopracovní tok zpracování obrazu k dosažení přizpůsobených resingových operacíspecifické požadavky vaší žádosti.

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

Parameters

newWidth int

A nová šířka.

newHeight int

A nová výška.

settings ImageResizeSettings

Zpětné nastaven.

ResizeHeightProportionally(Zpět, ResizeType)

Přizpůsobte výšku obrazu přiměřeně, při zachování jeho vzájemného poměruIntegrujte tuto metodu do vašeho pracovního toku zpracování obrazudynamicky rezignovat snímky v jednotných poměrech, zajistit optimální zobrazení neboUložení v rámci vaší aplikace.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

A nová výška.

resizeType ResizeType

Druh odrůdy.

ResizeWidthProportionally(Zpět, ResizeType)

Proporcionálně upravit šířku obrazu při zachování jeho aspektního poměru.Integrujte tuto metodu do vašeho pracovního toku pro zpracování obrazu, abyste dynamicky obnovilisnímky s konzistentními poměry, které zajišťují optimální zobrazení nebo ukládání vVaše žádost.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

A nová šířka.

resizeType ResizeType

Druh odrůdy.

Rotate(plavba, bool, barva)

Obrázek otáčí kolem jeho centra určitým úhlem, zatímco poměrněopakovat a aplikovat specifikované farební parametry pozadí.metodu do vašeho pracovního toku zpracování obrazu k dosažení přesných transformací spřizpůsobitelné barvy pozadí, které zajišťují optimální vizuální prezentaci v rámci vašehoAplikace.

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

Parameters

angle float

Otevírací úhel v stupních. pozitivní hodnoty se otáčí po hodin.

resizeProportionally bool

Pokud je nastaven na “skutečný”, budete mít velikost obrazu změněna v závislosti na rotačních rektangle (kornové body) projekce v jiném případě, které zanechávají rozměry nedotčené a pouzevnitřní obsah obrazu jsou rotačn.

backgroundColor Color

Barva pozad.

RotateFlip(RotateFlipType)

Aplikujte rotaci, flipping nebo obě operace výhradně na aktivní rámIntegrujte tuto metodu do vašeho pracovního toku zpracování obrazuzajišťuje přesnou manipulaci s jednotlivými rámy, zvyšuje flexibilitu aovládání transformací rámu v rámci vaší aplikace.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Typ rotujícího flip.

SaveData(Stream)

Ušetříme data.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Příliv pro ukládání dat.

UpdateDimensions(a int, int)

Aktualizace rozměrů obrazu.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Nové obrazové šířky.

newHeight int

Nová výška obrazu.

 Čeština