Class WebPImage

Class WebPImage

Nombre del espacio: Aspose.Imaging.FileFormats.Webp Asamblea: Aspose.Imaging.dll (25.4.0)

Manipular las imágenes de raster WebP con nuestra API, utilizando sus características modernas para ambosCompresión sin pérdidas y sin pérdidas, garantizando la calidad óptima de la imagen con los tamaños de archivo reducidos.Mantiene fácilmente formatos de archivo extendidos, animaciones y canales alfa, mientras que fácilmentela actualización de las dimensiones, la recreación proporcional, la recreación, la rotación, la aplicación de los filtros,ajustar los parámetros de la imagen, y convertir a otros formatos de la imagen para la versatilidadOptimización de la imagen 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 ,y, IObjectWithBounds ,y, IRasterImageArgb32PixelLoader ,y, IRasterImageRawDataLoader ,y, IHasXmpData ,y, IHasMetadata ,y, IMultipageImageExt ,y, IMultipageImage

Miembros heredados

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

Examples

Este ejemplo muestra cómo cargar una imagen WebP de un archivo y salvarlo a 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

Web Imágenes(Stream)

Instantiar una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage, iniciadade una fuente de flujo proporcionada. Utilice este constructor para crear WebP sin problemasObjetos de imagen directamente de los flujos, lo que permite un manejo y manipulación eficientesde los datos de imagen WebP dentro de su aplicación.

public WebPImage(Stream stream)

Parameters

stream Stream

El flujo de la imagen WebP.

Examples

Este ejemplo muestra cómo cargar una imagen WebP de un flujo de archivos y salvarlo a 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());
                                                                                             }

Web Imágenes(Opciones, LoadOptions)

Crea una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage utilizando un flujo yopciones de carga especificadas, facilitando el manejo versátil de los datos de imagen WebP.Incorporar este constructor para iniciar de forma indefinida los objetos de imagen WebP deflujos mientras personalizamos los parámetros de carga como sea necesario dentro de su aplicación.

public WebPImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

El flujo de la imagen WebP.

loadOptions LoadOptions

Las opciones de carga.

Web Imágenes(El string)

Instantiate una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage, iniciadade una fuente de archivo proporcionada. Utilice este constructor para crear WebP sin problemasobjetos de imagen directamente de los archivos, simplificando el proceso de carga ymanipular los datos de imagen WebP dentro de su aplicación.

public WebPImage(string path)

Parameters

path string

El camino hacia el archivo WebP Image

Examples

Este ejemplo muestra cómo cargar una imagen WebP de un archivo y salvarlo a 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());
                                                                                      }

Web Imágenes(Título: LoadOptions)

Crea una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage utilizando un archivo yopciones de carga especificadas, facilitando el manejo flexible de los datos de imagen WebP.este constructor para iniciar de forma indefinida los objetos de imagen WebP de los archivos mientraspersonalizar los parámetros de carga de acuerdo con los requisitos de su aplicación.

public WebPImage(string path, LoadOptions loadOptions)

Parameters

path string

El camino hacia el archivo WebP Image

loadOptions LoadOptions

Las opciones de carga.

Web Imágenes(RasterImage)

Instantiar una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage, iniciadade un objeto rasterImage proporcionado. este constructor permite laConversión de imágenes de raster en formato WebP, lo que permite un manejo eficiente ymanipulación de los datos de imagen dentro de su aplicación.

public WebPImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

La imagen del raster.

Examples

Este ejemplo muestra cómo crear una imagen WebP de otra imagen de 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());
                                                                                       }
                                                                                   }

Web Imágenes(Desarrollo, LoadOptions)

Crea una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage utilizando un objeto rasterImage yopciones de carga especificadas, que permiten el manejo flexible de los datos de imagen.Constructor para inicializar objetos de imagen WebP de imágenes raster mientraspersonalizar los parámetros de carga de acuerdo con los requisitos de su aplicación.

public WebPImage(RasterImage rasterImage, LoadOptions loadOptions)

Parameters

rasterImage RasterImage

La imagen del raster.

loadOptions LoadOptions

Las opciones de carga.

Web Imágenes(Int, Int y WebPOptions)

Instalar una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage con un vacíoimagen de las dimensiones especificadas de ancho y altura.Este constructor permite laCreación de imágenes WebP blancas, proporcionando una base para la imagen posteriormanipulación y generación de contenidos dentro de su aplicación.

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

Parameters

width int

El tamaño de la imagen

height int

La altura de la imagen.

options WebPOptions

Las opciones.

Examples

Este ejemplo muestra cómo crear una imagen WebP con las opciones especificadas a partir de los rastros.

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 ejemplo muestra cómo crear una imagen animada WebP multi-frame con las opciones 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");
                                                                                                         }

Web Imágenes(int, int, WebPOptions, LoadOptions)

Crea una nueva instancia de la clase Aspose.Imaging.FileFormats.Webp.WebPImage con una imagen vacía y especificadaOpciones de carga. este constructor permite la iniciación de las imágenes WebP conparámetros de carga personalizables, proporcionando flexibilidad en la creación de imágenes ymanipulación dentro de su aplicación.

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

Parameters

width int

El tamaño de la imagen

height int

La altura de la imagen.

options WebPOptions

Las opciones.

loadOptions LoadOptions

Las opciones de carga.

Properties

FileFormat

Acceso al valor de formato de archivo asociado con la imagen, proporcionando informaciónsobre el formato en el que se almacena la imagen. Utilice esta propiedad para determinarel formato de archivo de la imagen, facilitando las verificaciones de compatibilidad yProcesamiento específico de formato dentro de su aplicación.

public override FileFormat FileFormat { get; }

Valor de la propiedad

FileFormat

HasAlpha

Recuerda si la imagen contiene un canal alfa, indicando la presencia deinformación de transparencia. Utilice esta propiedad para determinar si la imagenincluye la transparencia, que permita el tratamiento y el tratamiento adecuados deOperaciones alfa relacionadas dentro de su aplicación.

public override bool HasAlpha { get; }

Valor de la propiedad

bool

Examples

El siguiente ejemplo carga una imagen de WEBP y imprime información sobre el formato de datos crudos y el 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

Recuperar o modificar las opciones asociadas con la propiedad especificada, permitiendoLa personalización del comportamiento y de los ajustes.Utilizar esta propiedad paraAcceso sin sentido y manipulación de los parámetros configurables, facilitando la versatilidadControl y optimización dentro de la funcionalidad de su aplicación.

[JsonProperty]
public WebPOptions Options { get; }

Valor de la propiedad

WebPOptions

PageCount

Retirar el número total de páginas dentro del documento especificado, facilitandoeficiente navegación y gestión de contenidos de múltiples páginas.funcionalidad para mejorar la experiencia del usuario, permitiendo el acceso sinestructuras documentales completas.

public override int PageCount { get; }

Valor de la propiedad

int

Pages

Acceso a los bloques WebP dentro de la imagen, permitiendo un examen detallado omanipulación de la estructura de bloque subyacente. Utilice esta propiedad para analizaro modificar los bloques individuales dentro de los datos de la imagen WebP, facilitandoTécnicas de procesamiento de imágenes dentro de su aplicación.

public override Image[] Pages { get; }

Valor de la propiedad

Image [][]

Methods

AddBlock(El IFRAM)

Incorporar un nuevo bloque WebP en la imagen, enriquecendo su contenido yfacilitando la manipulación avanzada de la imagen.Integra este método amejora la estructura y la complejidad de los datos de imagen WebP dentro de suAplicación, que permite el control preciso y la optimización de la renderización de la imagen.

public void AddBlock(IFrame block)

Parameters

block IFrame

El bloqueo Webp para añadir.

Examples

Este ejemplo muestra cómo crear una imagen animada WebP multi-frame con las opciones 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)

Añadir una nueva página a la imagen, ampliar su contenido y alojar másElementos visuales.Integrar este método para facilitar la gestión de página dinámicadentro de su aplicación, permitiendo la creación y la ampliación sin límites de múltiples páginasdocumentos o imágenes.

public void AddPage(RasterImage page)

Parameters

page RasterImage

La página para añadir.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Implementar el ajuste de claridad para la imagen, permitiendo la themodificación de los niveles de luminosidad general. Incorporar este método en su flujo de trabajo de procesamiento de imágenes para mejorar la visibilidad y mejorar la calidad visual de las imágenes dentro de su aplicación.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Valor de brillo.

AdjustContrast(float)

Mejora el contraste del Aspose.Imaging.Image, amplificando eldiferencias entre las áreas de luz y oscuridad.Integra este método en tu imagenprocesamiento del flujo de trabajo para mejorar la claridad visual y la calidad general de la imagen dentrosu solicitud.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Valor de contraste (en rango [-100; 100])

AdjustGamma(float)

Aplique la corrección gamma a la imagen, ajustando las intensidades de los píxeles aluces deseadas y equilibrio de color. Incorporar este método en su imagenprocesamiento del flujo de trabajo para mejorar la calidad visual y mejorar la precisión deposterior análisis o muestra tareas dentro de su aplicación.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma para los canales rojo, verde y azul coeficiente

AdjustGamma(float, float y float)

Performan la corrección gamma en la imagen utilizando coeficientes individuales para el rojo,canales verdes y azules, que permiten ajustes de equilibrio de color yIntegra este método en su pipeline de procesamiento de imágenes para lograrcontrol preciso sobre el rendimiento de colores y mejora la fidelidad visual dentro de suAplicación.

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

Parameters

gammaRed float

Gamma para el coeficiente de canal rojo

gammaGreen float

Gamma para el coeficiente de canal verde

gammaBlue float

Gamma para el coeficiente de canal azul

BinarizeBradley(El doble, int)

Aplique la binarización a la imagen utilizando el algoritmo de límite adaptativo de Bradleycon límite de imagen integral. este método computa dinámicamente locallímites basados en la vecindad de la imagen, mejorando la adaptabilidad a la variacióncondiciones de iluminación y garantizar una segmentación robusta para su posterior procesamientotareas dentro de su solicitud.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

La diferencia de brillo entre el pixel y la media de una ventana s x s de píxelesen torno a este pixel.

windowSize int

El tamaño de la ventana s x s de los píxeles centrados alrededor de este píxel

BinarizeFixed(El byte)

Performan la binarización en la imagen utilizando un valor límite predefinido, convertiendose convierte en una imagen binaria donde los píxeles se clasifican como antegrado o fondobasado en su intensidad relativa al límite. integrar este método ensu flujo de trabajo de procesamiento de imágenes para facilitar la segmentación y la extracción de característicastareas, mejorando la exactitud y eficacia de los análisis posteriores dentro de suAplicación.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Si el valor gris correspondiente de un pixel es mayor que el límite, un valor de255 se asignará a ella, 0 de otra manera.

BinarizeOtsu()

Performan la binarización en la imagen utilizando el método de límite de Otsu, automáticamentedeterminar el valor del límite óptimo basado en el histograma de la imagen.este método en su flujo de trabajo de procesamiento de imágenes para lograr una segmentación efectivay la extracción de características, mejorando la exactitud y fiabilidad de la análisis de imagentareas dentro de su solicitud.

public override void BinarizeOtsu()

ClearBlocks()

Limpiar todos los bloques WebP existentes de la imagen, facilitando la limpieza deModificaciones o adiciones posteriores. Utilice este método para reinstalar de forma efectivala estructura de bloque dentro de los datos de imagen WebP, garantizando una gestión óptima yOrganización de contenido de imagen dentro de su aplicación.

public void ClearBlocks()

Crop(Rectangle)

Cultivar la imagen utilizando una región rectangular especificada, eliminando porciones no deseadasmanteniendo el contenido deseado.Integra este método en tu imagenprocesamiento del flujo de trabajo para extraer con precisión y centrarse en áreas específicas de interésdentro de la imagen, mejorando la claridad y la composición para diferentes aplicaciones.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

El rectángulo.

Crop(Int, int, int, int)

Cultivar la imagen aplicando los cambios de izquierda, derecha, arriba y abajo, de manera efectivaseleccionar una región de interés dentro de la imagen. Utilice este método paraextraer dinámicamente las partes deseadas de la imagen al ajustar su composicióny se centra de acuerdo con los requisitos de su aplicación.

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

Parameters

leftShift int

El cambio de izquierda.

rightShift int

El cambio correcto.

topShift int

El cambio superior.

bottomShift int

El cambio de fondo.

Dither(DitheringMétodo, int, IColorPalette)

Performan la difusión en la imagen actual para reducir la bandera de color y mejorar la visualidadIntegra este método en su flujo de trabajo de procesamiento de imágenes para lograrMejorar las transiciones entre los colores y mejorar la apariencia general de losImagen dentro de su aplicación.

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

Parameters

ditheringMethod DitheringMethod

El método de difusión.

bitsCount int

Los últimos bits cuentan para diitar.

customPalette IColorPalette

La paleta personalizada para la difusión.

Filter(Rectangle, FilterOptionsBase)

Filtrar el contenido dentro del rectángulo especificado, aplicando una imagen designadafiltros de procesamiento para mejorar o modificar la región seleccionada.en su flujo de trabajo de manipulación de imagen para lograr mejoras dirigidas otransformaciones dentro de su aplicación.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

El rectángulo.

options FilterOptionsBase

Las opciones.

Examples

El siguiente ejemplo aplica varios tipos de filtros a una imagen 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()

Convertir la imagen en su representación griscal, transformándola en unaImagen de un solo canal donde cada pixel representa la intensidad o la luminosidad.este método en su pipeline de procesamiento de imágenes para simplificar el análisis y mejorarcompatibilidad con algoritmos basados en grayscale, facilitando varios ordenadorestareas de visión y análisis de imagen dentro de su aplicación.

public override void Grayscale()

InsertBlock(Título: Iframe)

Insertar un nuevo bloque WebP en el índice especificado dentro de la imagen, permitiendo la precisióncontrol sobre la secuencia de bloques.Integra este método para incorporar de forma indefinidabloqueos WebP adicionales en la estructura de datos de la imagen, facilitando la imagen avanzadaprocesamiento y optimización dentro de su aplicación.

public void InsertBlock(int index, IFrame block)

Parameters

index int

El elemento basado en cero, en el que block’ se insertar.

block IFrame

El bloqueo Webp para añadir.

ReleaseManagedResources()

Emite los recursos gestionados. asegúrese de que no se liberan los recursos no gestionados aquí, ya que pueden haber sidoya liberados.

protected override void ReleaseManagedResources()

RemoveBlock(El IFRAM)

Remover el bloque WebP especificado de la imagen, facilitando una gestión eficientede estructura de datos de imagen. Utilice este método para simplificar el procesamiento de imagenflujos de trabajo eliminando bloques o componentes innecesarios dentro de su aplicación.

public void RemoveBlock(IFrame block)

Parameters

block IFrame

El bloque para eliminar.

Remarks

Nota: no te olvides de Disponer el bloque " si no quieres agregarlo a algún otro WebPImage.

Resize(int, int, resizeType)

Recuperar la imagen, ajustando sus dimensiones mientras se conserva la relación de aspecto.Integra este método en su flujo de trabajo de procesamiento de imágenes para escalar dinámicamenteimágenes para adaptarse a diferentes requisitos de pantalla o almacenamiento dentro de su aplicación.

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

Parameters

newWidth int

La nueva amplitud.

newHeight int

La nueva altura.

resizeType ResizeType

El tipo de residuos.

Examples

Este ejemplo carga una imagen de WEBP y la resisa utilizando diferentes métodos de resisación.

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

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

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

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

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

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

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

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

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

Resize(int, int, ImageResizeSettings)

Recuperar la imagen de acuerdo con las configuraciones especificadas, permitiendo el control preciso dedimensiones, la relación de aspecto, y el comportamiento de escalación.Integra este método en tuflujo de trabajo de procesamiento de imágenes para lograr las operaciones de resignación personalizadas adaptadas alos requisitos específicos de su solicitud.

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

Parameters

newWidth int

La nueva amplitud.

newHeight int

La nueva altura.

settings ImageResizeSettings

los ajustes de residuos.

ResizeHeightProportionally(Int, ResizeType)

Ajuste la altura de la imagen proporcionalmente, al mismo tiempo que conserva su relación de aspectoIntegra este método en su flujo de trabajo de procesamiento de imágenespara resignar dinámicamente las imágenes con proporciones uniformes, garantizando la visualización óptima oalmacenamiento dentro de su aplicación.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

La nueva altura.

resizeType ResizeType

Tipo de residuos.

ResizeWidthProportionally(Int, ResizeType)

Ajuste proporcionalmente la anchura de la imagen mientras mantiene su relación de aspecto.Integra este método en su flujo de trabajo de procesamiento de imágenes para resignar dinámicamenteimágenes con proporciones consistentes, garantizando la visualización o almacenamiento óptimos dentrosu solicitud.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

La nueva amplitud.

resizeType ResizeType

Tipo de residuos.

Rotate(float, bool, color)

Rotar la imagen alrededor de su centro por un ángulo especificado, mientras proporcionalrecubrirlo y aplicar los parámetros de color de fondo especificados.método en su flujo de trabajo de procesamiento de imagen para lograr transformaciones precisas concolores de fondo personalizables, garantizando la presentación visual óptima dentro de suAplicación.

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

Parameters

angle float

El ángulo de rotación en grados. valores positivos rotarán de manera horaria.

resizeProportionally bool

si se establece a ‘verdad’ tendrás su tamaño de imagen cambiado de acuerdo con las proyecciones rectangulares rotadas (puntos de corno) en otros casos que dejan las dimensiones no tocadas y sólo los contenidos de la imagen internal son rotados.

backgroundColor Color

El color del fondo.

RotateFlip(RotateFlipType)

Aplique la rotación, la flipping o ambas operaciones exclusivamente al marco activo.Integra este método en su flujo de trabajo de procesamiento de imágenes pararealizar una manipulación precisa de los cadros individuales, mejorar la flexibilidad ycontrol sobre las transformaciones del marco dentro de su aplicación.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

El tipo de flip rotado.

SaveData(Stream)

ahorrar los datos.

protected override void SaveData(Stream stream)

Parameters

stream Stream

El flujo para salvar los datos a.

UpdateDimensions(El int, int)

Actualizar las dimensiones de la imagen.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

La nueva imagen es amplia.

newHeight int

El nuevo tamaño de la imagen.

 Español