Class WebPImage

Class WebPImage

Il nome: Aspose.Imaging.FileFormats.Webp Assemblea: Aspose.Imaging.dll (25.4.0)

Manipolare le immagini del raster WebP con la nostra API, utilizzando le sue funzionalità moderne per entrambicompressione senza perdite, garantendo la qualità dell’immagine ottimale con dimensioni di file ridotte.Gestire senza sforzo formati di file estesi, animazioni e canali alfa, mentre facilmenteaggiornare le dimensioni, riprendere proporzionalmente, raccogliere, girare, applicare i filtri,adattare i parametri dell’immagine, e convertire in altri formati di immagine per versatileOttimizzazione dell’immagine web.

[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

I membri ereditari

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

Questo esempio mostra come caricare un’immagine WebP da un file e salvare in 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

Il WebPimage(Stream)

Instantare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp. WebPImage, inizializzatoUtilizzare questo costruttore per creare senza sforzo WebPoggetti di immagine direttamente dai flussi, consentendo una gestione efficiente e la manipolazionedei dati di immagine WebP all’interno della tua applicazione.

public WebPImage(Stream stream)

Parameters

stream Stream

Il flusso di WebP immagine.

Examples

Questo esempio mostra come caricare un’immagine WebP da un flusso di file e salvare in 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());
                                                                                             }

Il WebPimage(LoadOptions e LoadOptions)

Creare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp. WebPImage utilizzando un flusso eopzioni di caricamento specificate, facilitando il trattamento versatile dei dati di immagine WebP.Incorporare questo costruttore per inizializzare senza sforzo gli oggetti di immagine WebP daStreams mentre personalizzare i parametri di caricamento come necessario all’interno della tua applicazione.

public WebPImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Il flusso di WebP immagine.

loadOptions LoadOptions

Le opzioni di carico.

Il WebPimage(String)

Instantare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp. WebPImage, inizializzatoUtilizzare questo costruttore per creare senza sforzo WebPoggetti immagine direttamente dai file, semplificando il processo di caricamento emanipolare i dati di immagine WebP all’interno della tua applicazione.

public WebPImage(string path)

Parameters

path string

Il percorso per il file WebP Image

Examples

Questo esempio mostra come caricare un’immagine WebP da un file e salvare in 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());
                                                                                      }

Il WebPimage(String, LoadOptions)

Creare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp. WebPImage utilizzando un file eopzioni di caricamento specificate, che facilitano la gestione flessibile dei dati di immagine WebP.Questo costruttore per inizializzare senza sforzo gli oggetti di immagine WebP dai file mentrepersonalizzare i parametri di caricamento in base alle esigenze della tua applicazione.

public WebPImage(string path, LoadOptions loadOptions)

Parameters

path string

Il percorso per il file WebP Image

loadOptions LoadOptions

Le opzioni di carico.

Il WebPimage(RasterImage)

Instantare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp. WebPImage, inizializzatoda un fornito rasterImmagine oggetto. Questo costruttore consente diConversione delle immagini di raster in formato WebP, consentendo una gestione efficiente emanipolazione dei dati dell’immagine all’interno della tua applicazione.

public WebPImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

L’immagine del raster.

Examples

Questo esempio mostra come creare un’immagine WebP da un altro raster.

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

Il WebPimage(Immagini, LoadOptions)

Creare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp.webPimage utilizzando un rasterImage oggetto eopzioni di carico specificate, che consentono un trattamento flessibile dei dati dell’immagine.Constructor per inizializzare senza sforzo gli oggetti di immagine WebP da immagini di raster mentrepersonalizzare i parametri di caricamento in base alle esigenze della tua applicazione.

public WebPImage(RasterImage rasterImage, LoadOptions loadOptions)

Parameters

rasterImage RasterImage

L’immagine del raster.

loadOptions LoadOptions

Le opzioni di carico.

Il WebPimage(int, int e WebPOptions)

Instantare una nuova instanza del Aspose.Imaging.FileFormats.Webp. WebPImage classe con un vuotol’immagine di dimensioni specificate di larghezza e altezza.Questo costruttore consente dicreazione di immagini WebP bianche, fornendo una base per l’immagine successivaManipolazione e generazione di contenuti all’interno della tua applicazione.

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

Parameters

width int

La larghezza dell’immagine

height int

L’altezza dell’immagine

options WebPOptions

Le opzioni .

Examples

Questo esempio mostra come creare un’immagine WebP con le opzioni specificate da 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");
                                                                                                 }

Questo esempio mostra come creare un’immagine WebP animata multi-frame con le opzioni specificate.

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

Il WebPimage(Int, int, WebPOptions, LoadOptions)

Creare una nuova instanza della classe Aspose.Imaging.FileFormats.Webp.webPimage con un’immagine vuota e specificataQuesto costruttore consente l’inizializzazione delle immagini WebP conparametri di caricamento personalizzabili, fornendo flessibilità nella creazione dell’immagine eManipolazione all’interno della tua applicazione.

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

Parameters

width int

La larghezza dell’immagine

height int

L’altezza dell’immagine

options WebPOptions

Le opzioni .

loadOptions LoadOptions

Le opzioni di carico.

Properties

FileFormat

Accedere al valore del formato del file associato all’immagine, fornire informazionisul formato in cui viene immagazzinato l’immagine. Utilizzare questa proprietà per determinareil formato del file dell’immagine, facilitando i controlli di compatibilità eelaborazione specifica del formato all’interno della tua applicazione.

public override FileFormat FileFormat { get; }

Valore di proprietà

FileFormat

HasAlpha

Retrate se l’immagine contiene un canale alfa, indicando la presenza diinformazioni di trasparenza. Utilizzare questa proprietà per determinare se l’immaginecomprende la trasparenza, consentendo il corretto trattamento e elaborazione dioperazioni alfa-relate all’interno della tua applicazione.

public override bool HasAlpha { get; }

Valore di proprietà

bool

Examples

L’esempio seguente carica un’immagine WEBP e stampa informazioni sul formato dei dati crudi e sul canale 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

Ristrutturare o modificare le opzioni associate alla proprietà specificata, consentendoadeguata personalizzazione del comportamento e delle impostazioni. utilizzare questa proprietà perl’accesso e la manipolazione dei parametri configurabili, facilitando il versatileControllo e ottimizzazione all’interno della funzionalità dell’applicazione.

[JsonProperty]
public WebPOptions Options { get; }

Valore di proprietà

WebPOptions

PageCount

Retrate il numero totale di pagine nel documento specificato, facilitandonavigazione efficiente e gestione dei contenuti multi-pagine.funzionalità per migliorare l’esperienza utente, consentendo accesso senza precedenti astrutture documentali complessive.

public override int PageCount { get; }

Valore di proprietà

int

Pages

accedere ai blocchi WebP all’interno dell’immagine, consentendo un esame dettagliato omanipolazione della struttura del blocco sottostante. Utilizzare questa proprietà per analizzareo modificare i singoli blocchi all’interno dei dati dell’immagine WebP, facilitando l’avanguardiaTecniche di elaborazione dell’immagine all’interno della tua applicazione.

public override Image[] Pages { get; }

Valore di proprietà

Image [ ]

Methods

AddBlock(di Iframe)

Incorporare un nuovo blocco WebP nell’immagine, arricchendo il suo contenuto efacilitare la manipolazione dell’immagine avanzata. integrare questo metodo in modo dinamicomigliorare la struttura e la complessità dei dati di immagine WebP all’interno del vostroapplicazione, che consente il controllo accurato e l’ottimizzazione del rendering dell’immagine.

public void AddBlock(IFrame block)

Parameters

block IFrame

Il blocco Webp per aggiungere.

Examples

Questo esempio mostra come creare un’immagine WebP animata multi-frame con le opzioni specificate.

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)

Aggiungi una nuova pagina all’immagine, espandere il suo contenuto e accogliere ulterioriintegrare questo metodo per facilitare la gestione dinamica della paginaall’interno della tua applicazione, consentendo la creazione e l’aumento senza sfiore di molte pagineDocumenti o immagini.

public void AddPage(RasterImage page)

Parameters

page RasterImage

La pagina da aggiungere.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(int)

Implementare l’adeguamento di luminosità per l’immagine, consentendo la themodificazione dei livelli di illuminazione complessivi. Incorporare questo metodo nel tuo flusso di lavoro di elaborazione dell’imagine per migliorare la visibilità e la qualità visiva delle immagini nell’applicazione.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Il valore della luminosità.

AdjustContrast(flotta)

Migliora il contrasto del Aspose.Imaging.Immagine, amplificando ildifferenze tra aree di luce e buio. integrare questo metodo nella tua immagineelaborazione del flusso di lavoro per migliorare la chiarezza visiva e la qualità dell’immagine globale all’internoLa tua domanda.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Valore di contrasto (in gamma [-100; 100])

AdjustGamma(flotta)

Applicare la correzione gamma all’immagine, adeguando le intensità dei pixel per raggiungereilluminazione e equilibrio dei colori desiderati. incorporare questo metodo nella tua immagineil flusso di lavoro di elaborazione per migliorare la qualità visiva e aumentare l’accuratezza delsuccessiva analisi o visualizzazione dei compiti all’interno della tua applicazione.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma per il coefficiente dei canali rosso, verde e blu

AdjustGamma(Flotta, flotta e flotta)

Eseguire la correzione gamma sull’immagine utilizzando coefficienti individuali per il rosso,green, e canali blu, consentendo adeguamenti fin-tuned di equilibrio colore eintegrare questo metodo nel tuo tubo di elaborazione dell’immagine per realizzarecontrollo accurato del rendering dei colori e migliorare la fedeltà visiva all’interno della tuadi applicazione.

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

Parameters

gammaRed float

Gamma per il coefficiente del canale rosso

gammaGreen float

Gamma per il coefficiente del canale verde

gammaBlue float

Gamma per il coefficiente del canale blu

BinarizeBradley(Il doppio int)

Applicare la binarizzazione all’immagine utilizzando l’algoritmo adattivo di Bradleycon l’intera soglia dell’immagine. questo metodo calcola dinamicamente il localelimiti basati sulla vicinanza dell’immagine, migliorando l’adattabilità per variarecondizioni di illuminazione e fornire una segmentazione robusta per il successivo trattamentocompiti all’interno della tua domanda.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

La differenza di luminosità tra il pixel e la media di una finestra s x s di pixellicentrato intorno a questo pixel.

windowSize int

La dimensione della finestra s x s dei pixel centrati intorno a questo pixel

BinarizeFixed(di byte)

Eseguire la binarizzazione sull’immagine utilizzando un valore limite predefinito, convertendosi inserisce in un’immagine binaria in cui i pixel sono classificati come precursori o sfondosulla base della loro intensità relativa al limite. integrare questo metodo inil tuo flusso di lavoro di elaborazione dell’immagine per facilitare la segmentazione e l’estrazione delle caratteristichecompiti, migliorando l’accuratezza ed efficienza dell’analisi successiva all’interno della vostradi applicazione.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Se il valore grigio corrispondente di un pixel è superiore al limite, un valore di255 sarà assegnato a esso, 0 altrimenti.

BinarizeOtsu()

Eseguire la binarizzazione sull’immagine utilizzando il metodo di margine di Otsu, automaticamentedeterminare il valore limite ottimale basato sull’istogramma dell’immagine.Questo metodo entra nel tuo flusso di lavoro di elaborazione dell’immagine per ottenere una segmentazione efficacee l’estrazione delle caratteristiche, migliorando la precisione e la affidabilità dell’analisi immaginecompiti all’interno della tua domanda.

public override void BinarizeOtsu()

ClearBlocks()

Rimuovere tutti i blocchi WebP esistenti dall’immagine, facilitando una puliziasuccessive modifiche o aggiunte. Utilizzare questo metodo per ripristinare efficacementela struttura del blocco all’interno dei dati di immagine WebP, assicurando una gestione ottimale eorganizzazione del contenuto dell’immagine all’interno della tua applicazione.

public void ClearBlocks()

Crop(Rectangle)

Piantare l’immagine utilizzando una regione rettangolare specificata, rimuovendo le porzioni indesideratemantenere il contenuto desiderato. integrare questo metodo nella tua immagineelaborazione del flusso di lavoro per estrarre con precisione e concentrarsi su aree specifiche di interesseall’interno dell’immagine, migliorando la chiarezza e la composizione per varie applicazioni.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

Il rectangolo .

Crop(int, int, int, int)

Coltivare l’immagine applicando le spostate sinistra, destra, superiore e inferiore, in modo efficaceselezionare una regione di interesse all’interno dell’immagine. Utilizzare questo metodo perestrarre in modo dinamico le parti desiderate dell’immagine mentre si adatta la sua composizionee concentrarsi secondo i requisiti della tua applicazione.

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

Parameters

leftShift int

La sinistra cambia.

rightShift int

Il giusto cambio.

topShift int

Il top shift.

bottomShift int

Il basso cambiamento.

Dither(DitheringMethod, int, IColorPalette)

Eseguire il digiuno sull’immagine corrente per ridurre il legame dei colori e migliorare la visioneintegrare questo metodo nel tuo flusso di lavoro di elaborazione dell’immagine per realizzareMigliorare le transizioni tra i colori e migliorare l’aspetto generale delImmagine all’interno della tua applicazione.

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

Parameters

ditheringMethod DitheringMethod

Il metodo di diffusione.

bitsCount int

I bit finali contano per il dithering.

customPalette IColorPalette

La paletta personalizzata per il dithering.

Filter(Rettangolo, FilterOptionsBase)

Filtrare il contenuto all’interno del rettangolo specificato, applicando un’immagine designatafiltro di elaborazione per migliorare o modificare la regione selezionata.nel tuo flusso di lavoro di manipolazione dell’immagine per ottenere miglioramenti mirati oTrasformazioni all’interno della tua applicazione.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

Il rectangolo .

options FilterOptionsBase

Le opzioni .

Examples

Il seguente esempio si applica a diversi tipi di filtri per un’immagine 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()

Convertire l’immagine nella sua rappresentazione grayscale, trasformandola in unaImmagine a singolo canale in cui ogni pixel rappresenta l’intensità o la luminosità.questo metodo nel tuo tubo di elaborazione dell’immagine per semplificare l’analisi e migliorarecompatibilità con gli algoritmi basati su grayscale, facilitando diversi computercompiti di visione e analisi dell’immagine all’interno della tua applicazione.

public override void Grayscale()

InsertBlock(di Iframe)

Inserisci un nuovo blocco WebP all’indice specificato nell’immagine, consentendo la precisionecontrolla la sequenza del blocco. integrare questo metodo per incorporare senza sforzoBlocchi WebP aggiuntivi nella struttura dei dati dell’immagine, facilitando la visualizzazione avanzataelaborazione e ottimizzazione all’interno della tua applicazione.

public void InsertBlock(int index, IFrame block)

Parameters

index int

L’elemento basato su zero, in cui block’ verrà inserito.

block IFrame

Il blocco Webp per aggiungere.

ReleaseManagedResources()

Rilascia le risorse gestite. assicurarsi che nessuna risorsa non gestita sia rilasciata qui, poiché potrebbero essere stategià rilasciato.

protected override void ReleaseManagedResources()

RemoveBlock(di Iframe)

Rimuovere il blocco WebP specificato dall’immagine, facilitando una gestione efficientedi struttura dei dati dell’immagine. Utilizzare questo metodo per semplificare il trattamento delle immaginiflussi di lavoro eliminando blocchi o componenti inutili all’interno dell’applicazione.

public void RemoveBlock(IFrame block)

Parameters

block IFrame

Il blocco da rimuovere.

Remarks

Nota: non dimenticare di disporre il blocco " se non si desidera aggiungerlo ad altri WebPImage.

Resize(int, int, resizeType)

Ristrutturare l’immagine, adattando le sue dimensioni mantenendo il rapporto di aspetto.Integrare questo metodo nel tuo flusso di lavoro di elaborazione dell’immagine per scalare dinamicamenteimmagini per adattare a vari requisiti di visualizzazione o di archiviazione all’interno della tua applicazione.

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

Parameters

newWidth int

La nuova larghezza.

newHeight int

La nuova altezza.

resizeType ResizeType

Il tipo di ritorno.

Examples

Questo esempio carica un’immagine di WEBP e la risuona utilizzando vari metodi di rigenerazione.

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, immagineResizeSettings)

Ristrutturare l’immagine secondo le impostazioni specificate, consentendo un controllo accuratodimensioni, rapporto di aspetto e comportamento di scalazione. integrare questo metodo nella tuaIl flusso di lavoro di elaborazione dell’immagine per realizzare le operazioni di ripristino personalizzatei requisiti specifici della tua domanda.

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

Parameters

newWidth int

La nuova larghezza.

newHeight int

La nuova altezza.

settings ImageResizeSettings

Il ripristino delle impostazioni.

ResizeHeightProportionally(Integrazione, ResizeType)

Adattare proporzionalmente l’altezza dell’immagine, mantenendo il suo rapporto di aspettointegrare questo metodo nel tuo flusso di lavoro di elaborazione dell’immagineper riprodurre in modo dinamico le immagini con proporzioni uniformi, assicurando una visualizzazione ottimale oConservazione all’interno della tua applicazione.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

La nuova altezza.

resizeType ResizeType

Tipo di ritorno.

ResizeWidthProportionally(Integrazione, ResizeType)

Adattare proporzionalmente la larghezza dell’immagine mantenendo il suo rapporto di aspetto.Integrare questo metodo nel tuo flusso di lavoro di elaborazione dell’immagine per rigenerare dinamicamenteImmagini con proporzioni coerenti, garantendo la visualizzazione ottimale o lo stoccaggio all’internoLa tua domanda.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

La nuova larghezza.

resizeType ResizeType

Tipo di ritorno.

Rotate(Flotta, Bool, Colore)

Rota l’immagine intorno al suo centro con un angolo specificato, mentre proporzionalmenteripristinare e applicare parametri di colore di sfondo specificati.metodi nel tuo flusso di lavoro di elaborazione dell’immagine per ottenere trasformazioni precise concolori di sfondo personalizzabili, assicurando la presentazione visiva ottimale all’interno della vostradi applicazione.

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

Parameters

angle float

L’angolo di rotazione in gradi. valori positivi gireranno in orologio.

resizeProportionally bool

se impostato a ’true’ avrai cambiato la dimensione dell’immagine in base alle proiezioni rettangoli rotate (punti corni) in altri casi che lasciano le dimensioni non toccate e solointerni i contenuti di immagine sono rotati.

backgroundColor Color

Il colore del background.

RotateFlip(RotateFlipType)

Applicare rotazione, flipping o entrambe le operazioni esclusivamente al quadro attivointegrare questo metodo nel tuo flusso di lavoro di elaborazione dell’immagine ala manipolazione accurata dei quadri individuali, aumentando la flessibilità eControllo delle trasformazioni quadro all’interno della tua applicazione.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Il tipo di flip rotato.

SaveData(Stream)

Salva i dati.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Il flusso per salvare i dati.

UpdateDimensions(di int, int)

Aggiornare le dimensioni dell’immagine.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

La nuova larghezza dell’immagine.

newHeight int

L’altezza della nuova immagine.

 Italiano