Class GifImage

Class GifImage

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

El archivo de imagen para el formato de intercambio gráfico (GIF)desarrolladores con herramientas versátiles para el procesamiento de imágenes de raster comprimidas yGIFs animados. ofrecen características como el manejo de metadatos XMP, paleta de coloresconfiguraciones, fondo y control de color transparente, configuraciones de opacidad, resize,crop, aplicación de filtros, correcciones de gama, ajuste de contraste, grayscaletransformación, y la conversión a otros formatos. esta API permite lamanipulación y mejora de las imágenes GIF para una amplia gama de aplicaciones.

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

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage RasterCachedMultipageImage GifImage

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

Exportación de parte de la animación de la imagen GIF basada en el intervalo de tiempo.

using (var image = Image.Load("Animation.gif"))
                                                                             {
                                                                                 var options = new GifOptions
                                                                                 {
                                                                                     FullFrame = true,
                                                                                     MultiPageOptions = new MultiPageOptions
                                                                                     {
                                                                                         Mode = MultiPageMode.TimeInterval,
                                                                                         TimeInterval = new TimeInterval(0, 400)
                                                                                     }
                                                                                 };

                                                                                 image.Save("PartOfAnimation.gif", options);
                                                                             }

Este ejemplo muestra cómo crear una imagen GIF y guardarla en un archivo.

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

                                                                              // Create a GIF Frame block of 100x100 px.
                                                                              using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                              {
                                                                                  // Fill the entire block in red.
                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(firstBlock);
                                                                                  Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                  gr.FillRectangle(brush, firstBlock.Bounds);

                                                                                  using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                  {
                                                                                      gifImage.Save(dir + "output.gif");
                                                                                  }
                                                                              }

Crea una imagen GIF multipágina utilizando imágenes de raster de una sola página.

static void Main(string[] args)
                                                                      {
                                                                          // Load frames
                                                                          var frames = LoadFrames("Animation frames").ToArray();

                                                                          // Create GIF image using the first frame
                                                                          using (var image = new GifImage(new GifFrameBlock(frames[0])))
                                                                          {
                                                                              // Add frames to the GIF image using the AddPage method
                                                                              for (var index = 1; index < frames.Length; index++)
                                                                              {
                                                                                  image.AddPage(frames[index]);
                                                                              }

                                                                              // Save GIF image
                                                                              image.Save("Multipage.gif");
                                                                          }
                                                                      }

                                                                      private static IEnumerable<rasterimage> LoadFrames(string directory)
                                                                      {
                                                                          foreach (var filePath in Directory.GetFiles(directory))
                                                                          {
                                                                              yield return (RasterImage)Image.Load(filePath);
                                                                          }
                                                                      }</rasterimage>

Constructors

GifImage(GifFrameBlock y IColorPalette)

Iniciar un nuevo objeto Aspose.Imaging.FileFormats.Gif.GifImage con los parámetros especificados paraprimer marco y paleta global. Comienza a gestionar imágenes GIF rápidamente, garantizandorepresentación exacta con ajustes personalizables para resultados óptimos.

public GifImage(GifFrameBlock firstFrame, IColorPalette globalPalette)

Parameters

firstFrame GifFrameBlock

El primer marco para iniciar la imagen gif con.

globalPalette IColorPalette

Nota: Si ambos firstFrame’ y globalPalette’ son nulos, entonces se utiliza la paleta global por defecto.

Examples

Este ejemplo muestra cómo crear una imagen GIF con una paleta personalizada y guardarla en un archivo.

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

                                                                                                    // Create a GIF Frame block of 100x100 px.
                                                                                                    using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                                    {
                                                                                                        // Fill the entire block in red.
                                                                                                        Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(firstBlock);
                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                        gr.FillRectangle(brush, firstBlock.Bounds);

                                                                                                        // Use 4-bit palette to reduce the image size. The quality can get worse.
                                                                                                        Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.Create4Bit();

                                                                                                        using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock, palette))
                                                                                                        {
                                                                                                            gifImage.Save(dir + "output.gif");
                                                                                                        }
                                                                                                    }

Exceptions

ArgumentNullException

El firstFrame’ no puede ser nulo

ArgumentException

El firstFrame’ ya pertenece a alguna otra imagen.

GifImageException

El globalPalette’ especificado debe contener las entradas contadas igual a la potencia de 2.El tamaño mínimo de la paleta es 2, el máximo es 256.

GifImage(GifFrameBlock)

Crear imágenes GIF se vuelve sin esfuerzo con Aspose.Imaging.FileFormats.Gif.GifImageCon sólo el primer parámetro Frame, entra en un mundo de dinámica.La comunicación visual.

public GifImage(GifFrameBlock firstFrame)

Parameters

firstFrame GifFrameBlock

El primer marco para iniciar la imagen gif con.

Examples

Este ejemplo muestra cómo crear una imagen GIF y guardarla en un archivo.

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

                                                                              // Create a GIF Frame block of 100x100 px.
                                                                              using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                              {
                                                                                  // Fill the entire block in red.
                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(firstBlock);
                                                                                  Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                  gr.FillRectangle(brush, firstBlock.Bounds);

                                                                                  using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                  {
                                                                                      gifImage.Save(dir + "output.gif");
                                                                                  }
                                                                              }

El siguiente ejemplo muestra cómo componer una imagen GIF animada de bloques GIF individuales.

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

                                                                                                       // Create a GIF image 100 x 100 px.
                                                                                                       // The first block is fully black by default.
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                                       {
                                                                                                           // 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 &lt;= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

                                                                                                               Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(block);
                                                                                                               gr.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                           for (int angle = 10; angle &lt;= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

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

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           gifImage.Save(dir + "animated_radar.gif");
                                                                                                       }

Exceptions

ArgumentNullException

El firstFrame’ no puede ser nulo

ArgumentException

El firstFrame’ ya pertenece a alguna otra imagen.

GifImageException

La paleta especificada debe contener entradas contadas igual a la potencia de 2.El tamaño mínimo de la paleta es 2, el máximo es 256.

GifImage(GifFrameBlock, IColorPalette, bool, byte, byte, byte, bool)

Comience sin esfuerzo con el constructor Aspose.Imaging.FileFormats.Gif.GifImage.método sencillo, se puede mergullar en la creación de gifs animados con facilidad.firstFrame, globalPalette, paletteColorResolution, aspectRatio, y otrosParámetros, y usted está listo para traer sus visuales a la vida.

public GifImage(GifFrameBlock firstFrame, IColorPalette globalPalette, bool isPaletteSorted, byte paletteColorResolution, byte paletteBackgroundColorIndex, byte aspectRatio, bool hasTrailer)

Parameters

firstFrame GifFrameBlock

El primer marco para iniciar la imagen gif con.

globalPalette IColorPalette

Nota: Si ambos firstFrame’ y globalPalette’ son nulos, entonces se utiliza la paleta global por defecto.

isPaletteSorted bool

Nota el parámetro se utiliza cuando globalPalette" no es nulo.

paletteColorResolution byte

Nota el parámetro se utiliza cuando globalPalette’ no es nulo.

paletteBackgroundColorIndex byte

El índice de color de fondo de paleta.

aspectRatio byte

La proporción del aspecto.

hasTrailer bool

si se establece para ‘verdadera’ la imagen gif tiene trailer de otra manera no hay trailer escrito al final de la corriente.

Exceptions

ArgumentNullException

El firstFrame’ no puede ser nulo

ArgumentException

El firstFrame’ ya pertenece a alguna otra imagen.

GifImageException

El globalPalette’ especificado debe contener las entradas contadas igual a la potencia de 2.El tamaño mínimo de la paleta es 2, el máximo es 256.

Properties

ActiveFrame

Gestionar y manipular los cuadros con esta propiedad, permitiendo una navegación suave yModificación del marco activo dentro de la imagen GIF.

public GifFrameBlock ActiveFrame { get; set; }

Valor de la propiedad

GifFrameBlock

Examples

El siguiente ejemplo muestra cómo eliminar todos los bloques de una imagen GIF.

using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                 using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                 {
                                                                                     if (gifImage.ActiveFrame != null)
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame size: {0}", gifImage.ActiveFrame.Size);
                                                                                     }
                                                                                     else
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame is not set");
                                                                                     }

                                                                                     System.Console.WriteLine("Clear all the blocks");
                                                                                     gifImage.ClearBlocks();

                                                                                     if (gifImage.ActiveFrame != null)
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame size: {0}", gifImage.ActiveFrame.Size);
                                                                                     }
                                                                                     else
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame is not set");
                                                                                     }
                                                                                 }

                                                                                 // The output looks like this:
                                                                                 // Active frame size: { Width = 100, Height = 100}
                                                                                 // Clear all the blocks
                                                                                 // Active frame is not set

BackgroundColor

Gestionar el color de fondo de la imagen GIF con esta propiedad.recuperar el color de fondo para garantizar la coherencia y mejorar el atractivo visual.

public override Color BackgroundColor { get; set; }

Valor de la propiedad

Color

BackgroundColorIndex

Controlar el índice de color de fondo de la imagen GIF utilizando esta propiedad.retire el índice para mantener la coherencia o obtener los efectos visuales deseados.

public byte BackgroundColorIndex { get; set; }

Valor de la propiedad

byte

Blocks

Obtenga acceso a los bloques GIF sin límites con esta propiedad, facilitando fácilmenteRecuperación y manipulación de las estructuras de datos subyacentes de la imagen.

public IGifBlock[] Blocks { get; }

Valor de la propiedad

IGifBlock [][]

FileFormat

Recuperar el formato de archivo sin esfuerzo con esta propiedad. es su fuentepara identificar el formato de sus archivos. integrados sin problemas en su flujo de trabajo,proporciona información vital sin ningún engaño.

public override FileFormat FileFormat { get; }

Valor de la propiedad

FileFormat

HasBackgroundColor

Esta propiedad determina si la imagen GIF contiene un color de fondo.verdad, indica que la imagen incluye un color de fondo.

public override bool HasBackgroundColor { get; }

Valor de la propiedad

bool

HasTrailer

Gestionar la presencia de un trailer en sus archivos GIF con esta propiedad.necesidad de comprobar si un trailer existe o establecer su presencia, esta propiedad simplifica laMantenga sus archivos GIF estructurados y conformes con esta característica intuitiva.

public bool HasTrailer { get; set; }

Valor de la propiedad

bool

HasTransparentColor

Determina si el marco activo de la imagen GIF incluye un color transparente.Esta propiedad proporciona una forma conveniente de comprobar la transparencia dentro de la imagen.

public override bool HasTransparentColor { get; set; }

Valor de la propiedad

bool

ImageOpacity

Retirar la opacidad del marco activo dentro de la imagen, ofreciendo una visiónsu nivel de transparencia. esta propiedad es particularmente útil para entender elgrado de transparencia o opacidad del marco activo en la imagen.

public override float ImageOpacity { get; }

Valor de la propiedad

float

IsInterlaced

Determina si la imagen está interligada, impactando su pantalla durante el cargamento.La propiedad ofrece una visión del comportamiento de rendimiento de la imagen, esencial paraoptimizar las estrategias de carga y mejorar la experiencia general de visualización.

public bool IsInterlaced { get; }

Valor de la propiedad

bool

IsPaletteSorted

Controlar la clasificación de la paleta en sus imágenes GIF utilizando esta propiedad.necesitas comprobar si la paleta está ordenada o establecer el comportamiento de ordenamiento, estepropiedad proporciona una forma sencilla de gestionar la organización de paleta en suLos archivos GIF.

public bool IsPaletteSorted { get; set; }

Valor de la propiedad

bool

LoopsCount

Retirar el número de loop sin esfuerzo con esta propiedad. si su imagen GIF incluyeinformación de loop, esta propiedad le da un acceso rápido al cálculo de loop, permitiendoUsted puede gestionar sin problemas el comportamiento de loop en sus archivos GIF.

public int LoopsCount { get; set; }

Valor de la propiedad

int

PageCount

Retirar el número total de páginas contenidas en la imagen con esteIdeal para evaluar rápidamente la extensión del contenido de la imagen.

public override int PageCount { get; }

Valor de la propiedad

int

Pages

Obtener acceso a las páginas dentro de la imagen a través de esta propiedad conveniente,Permite la navegación y manipulación de las páginas individuales según sea necesario.

public override Image[] Pages { get; }

Valor de la propiedad

Image [][]

PaletteColorResolutionBits

Gestión de la resolución de color de la paleta de tus imágenes GIF con esta propiedad.el número de bits utilizados para representar los colores en la paleta, proporcionando un buen controlsobre la profundidad de color y la calidad de la imagen.

public byte PaletteColorResolutionBits { get; set; }

Valor de la propiedad

byte

PixelAspectRatio

Gestionar la relación de aspecto de los píxeles de la imagen GIF con esta propiedad.proporción de aspecto para garantizar la rendición exacta y mantener la fidelidad visual.

public byte PixelAspectRatio { get; set; }

Valor de la propiedad

byte

TransparentColor

Retire el color transparente del marco activo en la imagen GIF. Esta propiedadte permite acceder al color específico que ha sido designado como transparentedentro del marco actual.

public override Color TransparentColor { get; }

Valor de la propiedad

Color

XmpData

Gestión de metadatos XMP con esta propiedad. si estás recuperando metadatos existenteso actualizarlo con nueva información, esta propiedad simplifica el proceso.sus metadatos organizados y accesibles, garantizando que sus archivos contieneninformación pertinente que necesitan.

public override XmpPacketWrapper XmpData { get; set; }

Valor de la propiedad

XmpPacketWrapper

Methods

AddBlock(El IGIFBlock)

La adición de un nuevo bloque GIF le permite incluir datos adicionales dentro de la imagen.Este método le permite añadir bloques personalizados a la imagen GIF, que puedeContiene diferentes tipos de información.

public void AddBlock(IGifBlock block)

Parameters

block IGifBlock

El bloque GIF para añadir.

Examples

El siguiente ejemplo muestra cómo componer una imagen GIF animada de bloques GIF individuales.

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

                                                                                                       // Create a GIF image 100 x 100 px.
                                                                                                       // The first block is fully black by default.
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                                       using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                                       {
                                                                                                           // 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 &lt;= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

                                                                                                               Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(block);
                                                                                                               gr.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                           for (int angle = 10; angle &lt;= 360; angle += 10)
                                                                                                           {
                                                                                                               Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock block = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100);

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

                                                                                                               gifImage.AddBlock(block);
                                                                                                           }

                                                                                                           gifImage.Save(dir + "animated_radar.gif");
                                                                                                       }

AddPage(RasterImage)

Incorporar una nueva página sin sentido en la imagen existente, mejorando su contenidoy ampliar su alcance. este método aumenta las colecciones de imágenes con máscontenido, fomentar la creatividad y la flexibilidad en la gestión de la imagen y la composición.

public void AddPage(RasterImage page)

Parameters

page RasterImage

La página para añadir.

Examples

Crea una imagen GIF multipágina utilizando imágenes de raster de una sola página.

static void Main(string[] args)
                                                                      {
                                                                          // Load frames
                                                                          var frames = LoadFrames("Animation frames").ToArray();

                                                                          // Create GIF image using the first frame
                                                                          using (var image = new GifImage(new GifFrameBlock(frames[0])))
                                                                          {
                                                                              // Add frames to the GIF image using the AddPage method
                                                                              for (var index = 1; index &lt; frames.Length; index++)
                                                                              {
                                                                                  image.AddPage(frames[index]);
                                                                              }

                                                                              // Save GIF image
                                                                              image.Save("Multipage.gif");
                                                                          }
                                                                      }

                                                                      private static IEnumerable<rasterimage> LoadFrames(string directory)
                                                                      {
                                                                          foreach (var filePath in Directory.GetFiles(directory))
                                                                          {
                                                                              yield return (RasterImage)Image.Load(filePath);
                                                                          }
                                                                      }</rasterimage>

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Ajusta la brillo de la imagen de acuerdo con el parámetro de brillo especificado.Este método modifica la brillo de la imagen entera de forma uniforme, mejorando o reduciendo la luminosidad general para alcanzar el efecto deseado.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Valor de brillo.

Examples

El siguiente ejemplo realiza la corrección de brillo de una imagen GIF.

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

                                                                               using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                               {
                                                                                   Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                   // Set the brightness value. The accepted values of brightness are in the range [-255, 255].
                                                                                   gifImage.AdjustBrightness(50);
                                                                                   gifImage.Save(dir + "sample.AdjustBrightness.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                               }

AdjustContrast(float)

Ajusta el contraste de la imagen, mejora o reduce la diferencia enbrillo entre píxeles.Este método modifica el alcance total de tonal de la imagen,hacer que las zonas más oscuras sean más oscuras y las zonas más brillantes para mejorar la claridad visualy los detalles.

public override void AdjustContrast(float contrast)

Parameters

contrast float

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

Examples

El siguiente ejemplo realiza la corrección de contraste de una imagen GIF.

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

                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                             {
                                                                                 Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                 // Set the contrast value. The accepted values of contrast are in the range [-100f, 100f].
                                                                                 gifImage.AdjustContrast(50f);
                                                                                 gifImage.Save(dir + "sample.AdjustContrast.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                             }

Exceptions

ImageException

No puede cambiar el contraste. índice de marco: " + frameIndex

AdjustGamma(float)

Mejora la calidad de la imagen mediante la aplicación de la corrección gamma. Este método ajusta el colorgama de la imagen para lograr la claridad visual óptima. Modifica el valor gammade cada píxel, lo que resulta en una mejor rendición de color y la apariencia general de la imagen.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma para los canales rojo, verde y azul coeficiente

Examples

El siguiente ejemplo realiza la corrección gamma de una imagen GIF.

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

                                                                          using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                          {
                                                                              Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                              // Set gamma coefficient for red, green and blue channels.
                                                                              gifImage.AdjustGamma(2.5f);
                                                                              gifImage.Save(dir + "sample.AdjustGamma.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                          }

AdjustGamma(float, float y float)

La corrección de gama de una imagen se aplica a un ajuste no lineal a los valores de los píxeles,Mejorar o reducir la luminosidad basada en los coeficientes especificados para el rojo,verde, y los canales azules. este método ayuda a limpiar el equilibrio de color yluminancia de la imagen, mejorando su apariencia general y calidad visual.

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

Examples

El siguiente ejemplo realiza la corrección gamma de una imagen GIF aplicando diferentes coeficientes para los componentes de color.

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

                                                                                                                               using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                               {
                                                                                                                                   Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                                   // Set individual gamma coefficients for red, green and blue channels.
                                                                                                                                   gifImage.AdjustGamma(1.5f, 2.5f, 3.5f);
                                                                                                                                   gifImage.Save(dir + "sample.AdjustGamma.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                               }

BinarizeBradley(doble)

Binarización de una imagen utilizando el algoritmo de límite adaptativo de Bradley conEl límite de imagen integral es un método para convertir una imagen de grayscale en unaEste algoritmo calcula un límite local para cada píxel basado enla intensidad media de los píxeles circundantes dentro de una ventana especificada.adaptivamente ajustando el límite basado en las intensidades de píxeles locales, BradleyEl método es eficaz en el manejo de variaciones en la iluminación y el contraste a través de la imagen.

public override void BinarizeBradley(double brightnessDifference)

Parameters

brightnessDifference double

La diferencia de brillo entre el pixel y la media de una ventana s x s de píxeles centrados alrededor de este pixel.

BinarizeFixed(El byte)

La binarización de una imagen con un límite predefinido converte una escalera gris o colorimagen en una imagen binaria, donde cada pixel está clasificado como negro o blancodependiendo de si su valor de intensidad supera un límite especificado.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

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

Examples

El siguiente ejemplo binariza una imagen GIF con el límite predefinido. imágenes binarias contienen sólo 2 colores - negro y blanco.

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

                                                                                                                                               using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                                               {
                                                                                                                                                   Aspose.Imaging.FileFormats.Gif.GifImage djvuImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                                                   // Binarize the image with a threshold value of 127.
                                                                                                                                                   // If a corresponding gray value of a pixel is greater than 127, a value of 255 will be assigned to it, 0 otherwise.
                                                                                                                                                   djvuImage.BinarizeFixed(127);
                                                                                                                                                   djvuImage.Save(dir + "sample.BinarizeFixed.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                               }

BinarizeOtsu()

La binarización de una imagen con el límite de Otsu es un método utilizado paradeterminar el valor del límite óptimo para convertir una imagen de escalera en unaEl algoritmo de los límites de Otsu calcula el límite queminimizar la variación intra-clases de las intensidades de los píxeles en los dos resultadoslas clases (antegrado y fondo). esta técnica es particularmente útil cuandoEl valor del límite óptimo es desconocido y debe determinarse de manera adaptativa.en el histograma de la imagen.

public override void BinarizeOtsu()

Examples

El siguiente ejemplo binariza una imagen GIF con el límite de Otsu. imágenes binarias contienen sólo 2 colores - negro y blanco.

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

                                                                                                                                        using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                                        {
                                                                                                                                            Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                                            // Binarize the image with Otsu thresholding.
                                                                                                                                            gifImage.BinarizeOtsu();
                                                                                                                                            gifImage.Save(dir + "sample.BinarizeOtsu.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                        }

ClearBlocks()

La limpieza de todos los bloques GIF elimina todos los datos existentes almacenados dentro de la imagen.Esta operación resuelve efectivamente la imagen a un estado vacío, eliminando cualquierutilice este método cuando necesita comenzar fresco con un limpiopara crear o modificar una imagen GIF.

public void ClearBlocks()

Examples

El siguiente ejemplo muestra cómo eliminar todos los bloques de una imagen GIF.

using (Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock firstBlock = new Aspose.Imaging.FileFormats.Gif.Blocks.GifFrameBlock(100, 100))
                                                                                 using (Aspose.Imaging.FileFormats.Gif.GifImage gifImage = new Aspose.Imaging.FileFormats.Gif.GifImage(firstBlock))
                                                                                 {
                                                                                     if (gifImage.ActiveFrame != null)
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame size: {0}", gifImage.ActiveFrame.Size);
                                                                                     }
                                                                                     else
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame is not set");
                                                                                     }

                                                                                     System.Console.WriteLine("Clear all the blocks");
                                                                                     gifImage.ClearBlocks();

                                                                                     if (gifImage.ActiveFrame != null)
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame size: {0}", gifImage.ActiveFrame.Size);
                                                                                     }
                                                                                     else
                                                                                     {
                                                                                         System.Console.WriteLine("Active frame is not set");
                                                                                     }
                                                                                 }

                                                                                 // The output looks like this:
                                                                                 // Active frame size: { Width = 100, Height = 100}
                                                                                 // Clear all the blocks
                                                                                 // Active frame is not set

Crop(Rectangle)

Cultivar la imagen utilizando una área rectangular especificada. esta operación elimina el exteriorporción de la imagen, dejando sólo la región seleccionada definida por el rectángulo.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

El rectángulo.

Examples

El siguiente ejemplo cultiva una imagen GIF. La zona de cultivo se especifica a través de Aspose.Imaging.Rectangle.

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

                                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                   {
                                                                                                                       Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                       // Crop the image. The cropping area is the rectangular central area of the image.
                                                                                                                       Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(gifImage.Width / 4, gifImage.Height / 4, gifImage.Width / 2, gifImage.Height / 2);
                                                                                                                       gifImage.Crop(area);

                                                                                                                       // Save the cropped image to PNG
                                                                                                                       gifImage.Save(dir + "sample.Crop.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                   }

Dither(DitheringMétodo, int, IColorPalette)

Aplicar la difusión a la imagen actual. Este proceso mejora la calidad de la imagen porReduce la bandera de color y mejora las transiciones de color, lo que resulta en una más suaveLa apariencia.

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.

Examples

El siguiente ejemplo carga una imagen GIF y realiza el límite y el fluido de dithering utilizando diferentes profundidades de paleta.

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

                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                            {
                                                                                                                                Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                                // Perform threshold dithering using 4-bit color palette which contains 16 colors.
                                                                                                                                // The more bits specified the higher quality and the bigger size of the output image.
                                                                                                                                // Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
                                                                                                                                gifImage.Dither(Aspose.Imaging.DitheringMethod.ThresholdDithering, 4, null);

                                                                                                                                gifImage.Save(dir + "sample.ThresholdDithering4.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                            }

                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                            {
                                                                                                                                Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                                // Perform floyd dithering using 1-bit color palette which contains only 2 colors - black and white.
                                                                                                                                // The more bits specified the higher quality and the bigger size of the output image.
                                                                                                                                // Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
                                                                                                                                gifImage.Dither(Aspose.Imaging.DitheringMethod.FloydSteinbergDithering, 1, null);

                                                                                                                                gifImage.Save(dir + "sample.FloydSteinbergDithering1.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                            }

Filter(Rectangle, FilterOptionsBase)

Aplique un filtro específico a la zona designada de la imagen, mejorando su visualidad.calidad o alterar su apariencia como se desea. este método procesará selectivamentepíxeles dentro del rectángulo definido, permitiendo que se realicen ajustesconservación de la integridad de los datos de imagen circundantes.

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 GIF.

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

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

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

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

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

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

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

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

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

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)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.
                                                                                     gifImage.Filter(gifImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
                                                                                     gifImage.Save(dir + "sample.MotionWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                 }

                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                 {
                                                                                     Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

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

GetOriginalOptions()

Recuperar las opciones basadas en la configuración de archivo original, esencial para mantener la fidelidady la coherencia en el procesamiento de imágenes y la manipulación. este método permite lala integración de los parámetros específicos de archivo en las operaciones posteriores, garantizandorendimiento exacto y adherencia a las características inherentes de la imagen.Esto puede ser útil para mantener la profundidad del bit y otros parámetros de la imagen original sin cambios.Por ejemplo, si cargamos una imagen de PNG en blanco y negro con 1 bito por píxel y luego la guardamos utilizando elAspose.Imaging.DataStreamSupporter.Save(System.String) método, la imagen PNG de salida con 8 bits por pixel se producir.Para evitarlo y ahorrar la imagen PNG con 1 bits por píxel, utilice este método para obtener las opciones de ahorro correspondientes y pasarlaspara el método Aspose.Imaging.Image.Save(System.String,Aspose.Imaging.ImageOptionsBase) como el segundo parámetro.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Las opciones basadas en las configuraciones de archivo original.

Grayscale()

La transformación de una imagen en su representación griega converte el colorImagen en una versión de escalera griega mediante la eliminación de la información de color mientras se conservaEste proceso simplifica la imagen a sombras de gris, lo que la convierte en adecuada.para diferentes aplicaciones como la impresión, el procesamiento de documentos y el grayscaleEl análisis.

public override void Grayscale()

Examples

El siguiente ejemplo transforma una imagen de GIF colorida en su representación de grayscale.Las imágenes de grayscale se componen exclusivamente de sombras de gris y solo llevan información de intensidad.

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

                                                                                                                                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                                                                                                  {
                                                                                                                                                                                                      Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                                                                                                                                      gifImage.Grayscale();
                                                                                                                                                                                                      gifImage.Save(dir + "sample.Grayscale.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                                                  }

InsertBlock(Título: IGIFBlock)

La inserción de un nuevo bloque de GIF le permite agregar datos personalizados en una posición específicadentro de la imagen. este método le permite colocar bloques personalizados en un deseadoubicación en la imagen GIF, proporcionando flexibilidad en la organización y estructuración de laDatos de imagen.

public void InsertBlock(int index, IGifBlock block)

Parameters

index int

El elemento basado en cero, en el que se insertará el bloque.

block IGifBlock

El bloque GIF para añadir.

OnPaletteChanged(Coloración, Coloración, Coloración)

Se llama cuando se cambia la paleta.

protected override void OnPaletteChanged(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

La vieja paleta.

newPalette IColorPalette

La nueva paleta.

OnPaletteChanging(Coloración, Coloración, Coloración)

Se llama cuando la paleta cambia.

protected override void OnPaletteChanging(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

La vieja paleta.

newPalette IColorPalette

La nueva paleta.

OrderBlocks()

Ordenar los bloques de GIF según la especificación de GIF garantiza el GIF adecuadoel diseño y el cumplimiento de la norma.Este proceso implica arreglar elbloqueos en la secuencia correcta como se define por la especificación.puede implicar la eliminación de ciertos Aspose.Imaging.FileFormats.Gif.Blocks.GifGraphicsControlBlock instantes queno son necesarios para el layout final. al adherirse a la especificación GIF, elLa imagen resultante será correctamente estructurada y compatible con la visualización GIFAplicaciones.

public void OrderBlocks()

RemoveBlock(El IGIFBlock)

Eliminar un bloque GIF elimina datos específicos de la imagen, ofreciendo la capacidad delimpiar o modificar la estructura de la imagen.Este método le permite eliminar los indeseadoso bloqueos innecesarios, optimizando la imagen GIF para un almacenamiento eficiente.Funcionalidad para eliminar la información obsoleta de la imagen mientras se conservasu integridad y calidad.

public void RemoveBlock(IGifBlock block)

Parameters

block IGifBlock

El bloque para eliminar.

Remarks

Nota: no te olvides de disponer el bloque si no lo agregas a otros GifImage.

Resize(int, int, resizeType)

Revisa este Aspose.Imaging.Image instancia.

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 GIF y la resisa utilizando diferentes métodos de resisación.

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

                                                                                        using (Aspose.Imaging.FileFormats.Gif.GifImage image = (Aspose.Imaging.FileFormats.Gif.GifImage)Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                        {
                                                                                            // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                            image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
                                                                                            image.Save(dir + "upsample.nearestneighbour.gif");
                                                                                        }

                                                                                        using (Aspose.Imaging.FileFormats.Gif.GifImage image = (Aspose.Imaging.FileFormats.Gif.GifImage)Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                        {
                                                                                            // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                            image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);
                                                                                            image.Save(dir + "downsample.nearestneighbour.gif");
                                                                                        }

                                                                                        using (Aspose.Imaging.FileFormats.Gif.GifImage image = (Aspose.Imaging.FileFormats.Gif.GifImage)Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                        {
                                                                                            // Scale up by 2 times using Bilinear resampling.
                                                                                            image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);
                                                                                            image.Save(dir + "upsample.bilinear.gif");
                                                                                        }

                                                                                        using (Aspose.Imaging.FileFormats.Gif.GifImage image = (Aspose.Imaging.FileFormats.Gif.GifImage)Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                        {
                                                                                            // Scale down by 2 times using Bilinear resampling.
                                                                                            image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);
                                                                                            image.Save(dir + "downsample.bilinear.gif");
                                                                                        }

Resize(int, int, ImageResizeSettings)

Revisa este Aspose.Imaging.Image instancia.

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

Parameters

newWidth int

La nueva amplitud.

newHeight int

La nueva altura.

settings ImageResizeSettings

Los establecimientos.

Examples

Este ejemplo carga una imagen GIF y la resisa utilizando diferentes configuraciones de resisación.

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

                                                                                         Aspose.Imaging.ImageResizeSettings resizeSettings = new Aspose.Imaging.ImageResizeSettings();

                                                                                         // The adaptive algorithm based on weighted and blended rational function and lanczos3 interpolation.
                                                                                         resizeSettings.Mode = Aspose.Imaging.ResizeType.AdaptiveResample;

                                                                                         // The small rectangular filter
                                                                                         resizeSettings.FilterType = Aspose.Imaging.ImageFilterType.SmallRectangular;

                                                                                         // The number of colors in the palette.
                                                                                         resizeSettings.EntriesCount = 256;

                                                                                         // The color quantization is not used
                                                                                         resizeSettings.ColorQuantizationMethod = ColorQuantizationMethod.None;

                                                                                         // The euclidian method
                                                                                         resizeSettings.ColorCompareMethod = ColorCompareMethod.Euclidian;

                                                                                         using (Aspose.Imaging.Image image = (Aspose.Imaging.Image)Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                         {
                                                                                             Aspose.Imaging.FileFormats.Gif.GifImage gifImage = (Aspose.Imaging.FileFormats.Gif.GifImage)image;

                                                                                             // Scale down by 2 times using adaptive resampling.
                                                                                             gifImage.Resize(image.Width / 2, image.Height / 2, resizeSettings);

                                                                                             // Save to PNG
                                                                                             gifImage.Save(dir + "downsample.adaptive.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

ResizeFullFrame(int, int, resizeType)

Recuperar la imagen al tener en cuenta los cuadros completos para cada página en unGIF, por lo que impide que aparezcan posibles artefactos. este método es esencialpara mantener la integridad y la calidad de la imagen, especialmente cuando se trata deGIFs animados o secuencias de cuadros.

public void ResizeFullFrame(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

La nueva amplitud.

newHeight int

La nueva altura.

resizeType ResizeType

El tipo de residuos.

ResizeProportional(int, int, resizeType)

La resignación proporcional mantiene la relación de aspecto de la imagen al ajustar su tamaño, garantizando que la imagen no aparezca estendida o distorcida.Este método resigna la imagen proporcionalmente, escalando tanto la anchura como la altura por el mismo factor.La resignación proporcional resigna cada marco según la relación de newWidth’/width y newHeight’/height.

public void ResizeProportional(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

La nueva amplitud.

newHeight int

La nueva altura.

resizeType ResizeType

El tipo de residuos.

Rotate(float, bool, color)

Este método rota la imagen alrededor de su punto central.en el ángulo, se puede rotar la imagen en forma de reloj o en forma de contra reloj para alcanzar elEsta rotación ayuda a ajustar la presentación de la imagen oAlineación sin distorsionar su contenido.

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)

Performan rotación, flipping, o ambos en el marco activo exclusivamente.aplica las transformaciones únicamente al marco actual activo de la imagen,Conservar la integridad de los demás cadros en la secuencia.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

El tipo de flip rotado.

Examples

Este ejemplo carga una imagen GIF, la rota por 90 grados al reloj y opcional flips la imagen horizontalmente y/o verticalmente.

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

                                                                                                                                             Aspose.Imaging.RotateFlipType[] rotateFlipTypes = new Aspose.Imaging.RotateFlipType[]
                                                                                                                                             {
                                                                                                                                                 Aspose.Imaging.RotateFlipType.Rotate90FlipNone,
                                                                                                                                                 Aspose.Imaging.RotateFlipType.Rotate90FlipX,
                                                                                                                                                 Aspose.Imaging.RotateFlipType.Rotate90FlipXY,
                                                                                                                                                 Aspose.Imaging.RotateFlipType.Rotate90FlipY,
                                                                                                                                             };

                                                                                                                                             foreach (Aspose.Imaging.RotateFlipType rotateFlipType in rotateFlipTypes)
                                                                                                                                             {
                                                                                                                                                 // Rotate, flip and save to the output file.
                                                                                                                                                 using (Aspose.Imaging.FileFormats.Gif.GifImage image = (Aspose.Imaging.FileFormats.Gif.GifImage)Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                                                 {
                                                                                                                                                     image.RotateFlip(rotateFlipType);
                                                                                                                                                     image.Save(dir + "sample." + rotateFlipType + ".png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                 }
                                                                                                                                             }

SaveData(Stream)

ahorrar los datos.

protected override void SaveData(Stream stream)

Parameters

stream Stream

El flujo para salvar los datos a.

SetFrameTime(Yucatán)

Ajusta la duración de cada marco en milisegundos, garantizando un timing consistenteen toda la secuencia de la imagen. este método establece uniformemente el tiempo de visualización paracada marco, lo que permite el control preciso de la velocidad de la animación.Modificar este valor retrasará el retraso para todos los cadros.

public void SetFrameTime(ushort time)

Parameters

time ushort

Duración del tiempo en millisegundos.

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