Class WebPImage

Class WebPImage

Nome do espaço: Aspose.Imaging.FileFormats.Webp Assembleia: Aspose.Imaging.dll (25.4.0)

Manipular imagens de raster WebP com a nossa API, usando suas funcionalidades modernas para ambosCompressão sem perda e compressão sem perda, garantindo a qualidade da imagem óptima com tamanhos de arquivo reduzidos.Gerenciar facilmente formatos de arquivos extensos, animações e canais alfa, enquanto facilmenteAtualização das dimensões, ressuscitação proporcional, colheita, rotação, aplicação de filtros,ajustar os parâmetros da imagem, e converter para outros formatos da imagem para versátilOtimização da imagem 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

Membros herdados

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

Este exemplo mostra como carregar uma imagem WebP de um arquivo e salvá-la para 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

WebPimagem(Stream)

Instante uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage, iniciadaa partir de uma fonte de fluxo fornecida.Utiliza este construtor para criar sem problemas WebPObjetos de imagem diretamente das correntes, permitindo uma manipulação e manipulação eficientesDados de imagem WebP dentro da sua aplicação.

public WebPImage(Stream stream)

Parameters

stream Stream

Imagem do Stream WebP.

Examples

Este exemplo mostra como carregar uma imagem WebP de um fluxo de arquivo e salvá-la para 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());
                                                                                             }

WebPimagem(Transmissão, LoadOptions)

Crie uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage usando um fluxo eopções de carregamento especificadas, facilitando o gerenciamento versátil de dados de imagem WebP.Incorporar este construtor para inicializar sem fio objetos de imagem WebP deStreams ao ajustar os parâmetros de carregamento conforme necessário dentro da sua aplicação.

public WebPImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Imagem do Stream WebP.

loadOptions LoadOptions

As opções de carga.

WebPimagem(Redação)

Instante uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage, iniciadade uma fonte de arquivo fornecida.Utilize este construtor para criar sem problemas WebPObjetos de imagem diretamente de arquivos, simplificando o processo de carregamento emanipulação de dados de imagem WebP dentro da sua aplicação.

public WebPImage(string path)

Parameters

path string

O caminho para o arquivo WebP Image

Examples

Este exemplo mostra como carregar uma imagem WebP de um arquivo e salvá-la para 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());
                                                                                      }

WebPimagem(Título: LoadOptions)

Crie uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage usando um arquivo eopções de carregamento especificadas, facilitando o gerenciamento flexível de dados de imagem do WebP.Este construtor para iniciar objetos de imagem WebP de arquivos enquantopersonalizar os parâmetros de carregamento de acordo com os requisitos da sua aplicação.

public WebPImage(string path, LoadOptions loadOptions)

Parameters

path string

O caminho para o arquivo WebP Image

loadOptions LoadOptions

As opções de carga.

WebPimagem(RasterImage)

Instante uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage, iniciadaa partir de um objeto fornecido rasterImage. Este construtor permite que oConversão de imagens de raster para o formato WebP, permitindo uma gestão eficiente emanipulação de dados de imagem dentro da sua aplicação.

public WebPImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

A imagem do rasto.

Examples

Este exemplo mostra como criar uma imagem WebP de outra imagem 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());
                                                                                       }
                                                                                   }

WebPimagem(Descrição, LoadOptions)

Crie uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage usando um objeto rasterImage eopções de carregamento especificadas, permitindo o gerenciamento flexível de dados de imagem.Constructor para iniciar objetos de imagem WebP de imagens de raster, enquantopersonalizar os parâmetros de carregamento de acordo com os requisitos da sua aplicação.

public WebPImage(RasterImage rasterImage, LoadOptions loadOptions)

Parameters

rasterImage RasterImage

A imagem do rasto.

loadOptions LoadOptions

As opções de carga.

WebPimagem(Int, Int e WebPOptions)

Instante uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage com um vazioimagem de dimensões de largura e altura especificadas. este construtor permite que ocriação de imagens WebP brancas, fornecendo uma base para a imagem subsequentemanipulação e geração de conteúdo dentro da sua aplicação.

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

Parameters

width int

A imagem de largura

height int

A altura da imagem.

options WebPOptions

As opções .

Examples

Este exemplo mostra como criar uma imagem WebP com as opções especificadas do 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");
                                                                                                 }

Este exemplo mostra como criar uma imagem animada WebP multi-frame com as opções especificadas.

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

WebPimagem(int, int, WebPOptions, LoadOptions)

Crie uma nova instância da classe Aspose.Imaging.FileFormats.Webp.WebPImage com uma imagem vazia e especificadaOpções de carregamento. este construtor permite a inicialização de imagens WebP comparâmetros de carregamento personalizáveis, proporcionando flexibilidade na criação de imagens emanipulação dentro da sua aplicação.

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

Parameters

width int

A imagem de largura

height int

A altura da imagem.

options WebPOptions

As opções .

loadOptions LoadOptions

As opções de carga.

Properties

FileFormat

Acesso ao valor do formato de arquivo associado à imagem, fornecendo informaçõessobre o formato em que a imagem é armazenada.Utiliza esta propriedade para determinaro formato de arquivo da imagem, facilitando verificações de compatibilidade eProcessamento específico de formato dentro da sua aplicação.

public override FileFormat FileFormat { get; }

Valor da propriedade

FileFormat

HasAlpha

Verifique se a imagem contém um canal alfa, indicando a presença deInformações de transparência.Utiliza esta propriedade para determinar se a imageminclui transparência, permitindo o tratamento e o tratamento adequados deOperações relacionadas ao alfa dentro da sua aplicação.

public override bool HasAlpha { get; }

Valor da propriedade

bool

Examples

O exemplo a seguir carrega uma imagem WEBP e imprime informações sobre o formato de dados crus e o canal 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

Retirar ou modificar as opções associadas com a propriedade especificada, permitindopersonificação de comportamento e configurações.Utiliza esta propriedade paraacessar e manipular parâmetros configuráveis, facilitando a versatilidadeControle e otimização dentro da funcionalidade da sua aplicação.

[JsonProperty]
public WebPOptions Options { get; }

Valor da propriedade

WebPOptions

PageCount

Retirar o número total de páginas dentro do documento especificado, facilitandoeficiente navegação e gerenciamento de conteúdos multi-páginas.funcionalidade para melhorar a experiência do usuário, permitindo o acesso sem fio aestruturas de documentos abrangentes.

public override int PageCount { get; }

Valor da propriedade

int

Pages

Acesso aos blocos WebP dentro da imagem, permitindo exame detalhado oumanipulação da estrutura do bloco subjacente.Utiliza esta propriedade para analisarou modificar blocos individuais dentro dos dados da imagem do WebP, facilitando o avançadoTécnicas de processamento de imagem dentro da sua aplicação.

public override Image[] Pages { get; }

Valor da propriedade

Image [ ]

Methods

AddBlock(Ifrão)

Incorporar um novo bloco WebP na imagem, enriquecendo seu conteúdo efacilitando a manipulação avançada da imagem. integrar este método paraMelhorar a estrutura e complexidade dos dados de imagem WebP dentro do seuaplicação, permitindo controle preciso e otimização da renderização de imagem.

public void AddBlock(IFrame block)

Parameters

block IFrame

O bloco Webp para adicionar.

Examples

Este exemplo mostra como criar uma imagem animada WebP multi-frame com as opções especificadas.

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)

Adicione uma nova página à imagem, expandir o seu conteúdo e acomodar adicionaisIntegrar este método para facilitar a gestão dinâmica da páginadentro da sua aplicação, permitindo a criação e a ampliação sem fundo de múltiplas páginasdocumentos ou imagens.

public void AddPage(RasterImage page)

Parameters

page RasterImage

Página para adicionar.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Implementar brightness’ ajustamento para a imagem, permitindo themodificação de níveis de luminância geral. Incorporar este método em seu fluxo de trabalho de processamento de imagem para melhorar a visibilidade e melhorar a qualidade visual das imagens dentro da sua aplicação.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Valor de brilho.

AdjustContrast(Flotação)

Melhora o contraste do Aspose.Imaging.Image, ampliando odiferenças entre áreas de luz e escuridão. integra este método em sua imagemprocessamento do fluxo de trabalho para melhorar a clareza visual e a qualidade geral da imagem dentroA sua aplicação.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Valor de contraste (em faixa [-100; 100])

AdjustGamma(Flotação)

Aplique a correção de gama para a imagem, ajustando as intensidades de pixel para alcançarbrilho desejado e equilíbrio de cores. Incorporar este método em sua imagemprocessamento do fluxo de trabalho para melhorar a qualidade visual e melhorar a precisão doAnálise subsequente ou tarefas de exibição dentro da sua aplicação.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma para os canais vermelho, verde e azul coeficiente

AdjustGamma(Flotas, Flotas e Flotas)

Faça correção de gama na imagem usando coeficientes individuais para o vermelho,canais verdes e azuis, permitindo ajustes finais de equilíbrio de cores eIntegra este método em seu tubo de processamento de imagem paracontrole preciso sobre a renderização de cores e melhora a fidelidade visual dentro do seuA aplicação.

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

Parameters

gammaRed float

Gamma para o Coeficiente de Canais Vermelhos

gammaGreen float

Gamma para o coeficiente de canais verdes

gammaBlue float

Gamma para o coeficiente de canais azuis

BinarizeBradley(duplo, int)

Aplique binarização à imagem usando o algoritmo de limite adaptativo de Bradleycom limite de imagem integral. este método computa dinâmicamente o locallimites com base na vizinhança da imagem, melhorando a adaptabilidade para variarcondições de iluminação e assegurar segmentação robusta para processamento posteriortarefas dentro da sua aplicação.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

A diferença de brilho entre o pixel e a média de uma janela s x s de pixelsO foco é em torno deste pixel.

windowSize int

O tamanho da janela s x s de pixels centrada em torno deste pixel

BinarizeFixed(em byte)

Faça binarização na imagem usando um valor-limite predefinido, convertendoem uma imagem binária onde os pixels são classificados como frontal ou de fundo.baseado na sua intensidade relativa ao limiar. integrar este método emseu fluxo de trabalho de processamento de imagem para facilitar a segmentação e a extração de recursostarefas, melhorando a precisão e eficiência da análise subsequente dentro da suaA aplicação.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Se o valor cinzento correspondente de um pixel for maior do que o limite, um valor de255 será atribuído a ele, 0 de outra forma.

BinarizeOtsu()

Faça binarização na imagem usando o método de limite do Otsu, automaticamentedeterminar o valor-limite ideal com base no histograma da imagem.Este método entra em seu fluxo de trabalho de processamento de imagem para alcançar uma segmentação eficaze extração de recursos, melhorando a precisão e fiabilidade da análise da imagemtarefas dentro da sua aplicação.

public override void BinarizeOtsu()

ClearBlocks()

Limpe todos os blocos WebP existentes da imagem, facilitando uma limpeza paraalterações ou adições subsequentes.Utiliza este método para reinstalar efetivamentea estrutura do bloco dentro dos dados da imagem WebP, assegurando a gestão óptima eOrganização de conteúdo de imagem dentro da sua aplicação.

public void ClearBlocks()

Crop(Rectangle)

Cultivar a imagem usando uma região rectangular especificada, removendo porções indesejadasMantenha o conteúdo desejado.Integra este método em sua imagemProcessamento de fluxo de trabalho para extrair e focar em áreas específicas de interessedentro da imagem, melhorando a clareza e composição para várias aplicações.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

do rectangulo.

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

Cultivar a imagem aplicando as mudanças esquerda, direita, superior e inferior, efetivamenteselecionar uma região de interesse dentro da imagem.Utilizar este método paraextrair dinâmicamente as porções desejadas da imagem ao ajustar a sua composiçãoe focar-se de acordo com os requisitos da sua aplicação.

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

Parameters

leftShift int

A esquerda mudou.

rightShift int

A mudança certa.

topShift int

O topo da mudança.

bottomShift int

A mudança do fundo.

Dither(DitheringMétodo, int, IColorPalette)

Performante diitar na imagem atual para reduzir a ligação de cores e melhorar a visãoIntegra este método em seu fluxo de trabalho de processamento de imagem paramelhoram as transições entre as cores e melhoram a aparência geral daImagem dentro da sua aplicação.

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

Parameters

ditheringMethod DitheringMethod

Metodologia do Dilúvio.

bitsCount int

Os bits finais contam para dithering.

customPalette IColorPalette

A paleta custom para dithering.

Filter(Rectangle, FilterOptionsBase)

Filtre o conteúdo dentro do rectangulo especificado, aplicando uma imagem designadafiltro de processamento para melhorar ou modificar a região selecionada.para o seu fluxo de trabalho de manipulação de imagem para alcançar melhorias alvo outransformações dentro da sua aplicação.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

do rectangulo.

options FilterOptionsBase

As opções .

Examples

O exemplo a seguir aplica vários tipos de filtros a uma imagem 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()

converte a imagem em sua representação grauscale, transformando-a em umaImagem de um único canal onde cada pixel representa intensidade ou luminância.este método para o seu tubo de processamento de imagem para simplificar a análise e melhorarCompatibilidade com algoritmos baseados em grayscale, facilitando vários computadoresTarefas de visão e análise de imagem dentro da sua aplicação.

public override void Grayscale()

InsertBlock(Título: Iframe)

Insira um novo bloco WebP no índice especificado dentro da imagem, permitindo precisãocontrole sobre a sequência de blocos. integrar este método para incorporar sem fioblocos WebP adicionais na estrutura de dados da imagem, facilitando a imagem avançadaProcessamento e otimização dentro da sua aplicação.

public void InsertBlock(int index, IFrame block)

Parameters

index int

O elemento baseado em zero, no qual block’ será inserido.

block IFrame

O bloco Webp para adicionar.

ReleaseManagedResources()

Assegure-se de que os recursos não gerenciados não são liberados aqui, uma vez que eles podem ter sidoJá foi liberado.

protected override void ReleaseManagedResources()

RemoveBlock(Ifrão)

Remova o bloco WebP especificado da imagem, facilitando a gestão eficientede estrutura de dados de imagem.Utiliza este método para simplificar o processamento de imagemfluxos de trabalho eliminando blocos ou componentes desnecessários dentro da sua aplicação.

public void RemoveBlock(IFrame block)

Parameters

block IFrame

O bloco é removido.

Remarks

Observação: não se esqueça de colocar o bloco " se você não quiser adicioná-lo a qualquer outro WebPImage.

Resize(Int, Int, ResizeType)

Recuperar a imagem, ajustando suas dimensões ao mesmo tempo que preservando a proporção de aspecto.Integra este método em seu fluxo de trabalho de processamento de imagem para escalar dinâmicamenteImagens para atender a diferentes requisitos de exibição ou armazenamento dentro da sua aplicação.

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

Parameters

newWidth int

A nova amplitude.

newHeight int

A nova altura.

resizeType ResizeType

O tipo de resgate.

Examples

Este exemplo carrega uma imagem WEBP e a resisa usando vários métodos de resisação.

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

Recuperar a imagem de acordo com as configurações especificadas, permitindo o controle exato dedimensões, proporção de aspecto e comportamento de escalação.Integra este método em seufluxo de trabalho de processamento de imagem para alcançar operações de reposição personalizadas adaptadas paraos requisitos específicos da sua aplicação.

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

Parameters

newWidth int

A nova amplitude.

newHeight int

A nova altura.

settings ImageResizeSettings

As definições de recessão.

ResizeHeightProportionally(Título: ResizeType)

Ajuste a altura da imagem proporcionalmente, ao mesmo tempo que preserve a sua relação de aspectoIntegra este método no seu fluxo de trabalho de processamento de imagempara resgatar dinâmicamente imagens com proporções uniformes, garantindo a visualização óptima ouarmazenamento dentro da sua aplicação.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

A nova altura.

resizeType ResizeType

Tipo de reposição.

ResizeWidthProportionally(Título: ResizeType)

Ajuste proporcionalmente a largura da imagem ao mesmo tempo que mantém a sua relação de aspecto.Integra este método no seu fluxo de trabalho de processamento de imagem para resgatar dinâmicamenteimagens com proporções consistentes, garantindo a visualização ou armazenamento óptimos dentroA sua aplicação.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

A nova amplitude.

resizeType ResizeType

Tipo de reposição.

Rotate(Float, Bool, Coloração)

Rotar a imagem em torno de seu centro por um ângulo especificado, enquanto proporcionalresumindo e aplicando parâmetros de cores de fundo especificados.método em seu fluxo de trabalho de processamento de imagem para alcançar transformações precisas comcores de fundo personalizáveis, garantindo a apresentação visual ideal dentro do seuA aplicação.

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

Parameters

angle float

O ângulo de rotação em graus. valores positivos girarão de maneira horária.

resizeProportionally bool

se configurado para ‘verdadeiro’ você terá o seu tamanho da imagem alterado de acordo com as projeções rectangular rotadas (puntos de corno) noutro caso que deixam as dimensões não tocadas e apenasinternal conteúdos da imagem são rotados.

backgroundColor Color

A cor do fundo.

RotateFlip(RotateFlipType)

Aplique rotação, flipping ou ambas as operações exclusivamente ao quadro ativointegrar este método em seu fluxo de trabalho de processamento de imagem paragarantir a manipulação precisa dos quadros individuais, melhorando a flexibilidade econtrole sobre as transformações de frame dentro da sua aplicação.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Tipo de flip rotativo.

SaveData(Stream)

Salve os dados.

protected override void SaveData(Stream stream)

Parameters

stream Stream

O fluxo para salvar dados para.

UpdateDimensions(Int, Int)

Atualiza as dimensões da imagem.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

A nova imagem de largura.

newHeight int

O novo tamanho da imagem.

 Português