Class GifImage

Class GifImage

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

A API para o formato de imagem de intercâmbio gráfico (GIF) forneceDesenvolvedores com ferramentas versáteis para processar imagens de raster comprimidas eGIFs animados. oferecendo recursos como o gerenciamento de metadados XMP, paleta de coresconfigurações, fundo e controle de cor transparente, configurações de opacidade, resize,crop, aplicação de filtro, correções de gama, ajuste de contraste, grayscaletransformação, e conversão para outros formatos. esta API permite semmanipulação e melhoria de imagens GIF para uma ampla gama de aplicações.

[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 , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata , IMultipageImageExt , IMultipageImage

Membros herdados

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

Examples

Exportação de parte da animação da imagem GIF com base no intervalo de tempo.

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 exemplo mostra como criar uma imagem GIF e salvá-la para um arquivo.

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

Crie uma imagem GIF multipágina usando imagens de raster de página única.

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 e IColorPalette)

Inicie um novo Objeto Aspose.Imaging.FileFormats.Gif.GifImage com parâmetros especificados paraPrimeiro quadro e paleta global. Comece a gerenciar imagens GIF rapidamente, garantindorepresentação precisa com configurações personalizáveis para resultados óptimos.

public GifImage(GifFrameBlock firstFrame, IColorPalette globalPalette)

Parameters

firstFrame GifFrameBlock

O primeiro quadro para iniciar a imagem gif com.

globalPalette IColorPalette

Observe se ambos firstFrame’ e globalPalette’ são nulos, então a paleta global padrão é usada.

Examples

Este exemplo mostra como criar uma imagem GIF com uma paleta personalizada e salvá-la para um arquivo.

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

O firstFrame’ não pode ser nulo

ArgumentException

A firstFrame’ já pertence a alguma outra imagem.

GifImageException

O globalPalette’ especificado deve conter contas equivalentes à potência de 2. o tamanho mínimo da paleta é 2, o máximo é 256.

GifImage(GifFrameBlock)

Criar imagens GIF torna-se sem esforço com o Aspose.Imaging.FileFormats.Gif.GifImageCom apenas o primeiro parâmetro Frame, entra num mundo dinâmico.comunicação visual.

public GifImage(GifFrameBlock firstFrame)

Parameters

firstFrame GifFrameBlock

O primeiro quadro para iniciar a imagem gif com.

Examples

Este exemplo mostra como criar uma imagem GIF e salvá-la para um arquivo.

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

O exemplo a seguir mostra como compilar uma imagem GIF animada de blocos GIF individuais.

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

O firstFrame’ não pode ser nulo

ArgumentException

A firstFrame’ já pertence a alguma outra imagem.

GifImageException

A paleta especificada deve conter entradas contas iguais à potência de 2. o tamanho mínimo da paleta é 2, o máximo é 256.

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

Comece sem esforço com o construtor Aspose.Imaging.FileFormats.Gif.GifImage.método simples, você pode mergulhar na criação de GIFs animados com facilidade.firstFrame, globalPalette, paletteColorResolution, aspectRatio, e outrosParâmetros, e você está pronto para trazer suas visões para a vida.

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

Parameters

firstFrame GifFrameBlock

O primeiro quadro para iniciar a imagem gif com.

globalPalette IColorPalette

Observe se ambos firstFrame’ e globalPalette’ são nulos, então a paleta global padrão é usada.

isPaletteSorted bool

Note que o parâmetro é usado quando globalPalette" não é nulo.

paletteColorResolution byte

Observe que o parâmetro é usado quando globalPalette’ não é nulo.

paletteBackgroundColorIndex byte

O índice de cores de fundo da paleta.

aspectRatio byte

A proporção do aspecto.

hasTrailer bool

se configurado para ‘verdadeiro’ a imagem gif tem trailer de outra forma nenhum trailer escrito no final da corrente.

Exceptions

ArgumentNullException

O firstFrame’ não pode ser nulo

ArgumentException

A firstFrame’ já pertence a alguma outra imagem.

GifImageException

O globalPalette’ especificado deve conter contas equivalentes à potência de 2. o tamanho mínimo da paleta é 2, o máximo é 256.

Properties

ActiveFrame

Gestão e manipulação de quadros com esta propriedade, permitindo uma navegação suave eModificação do quadro ativo dentro da imagem GIF.

public GifFrameBlock ActiveFrame { get; set; }

Valor da propriedade

GifFrameBlock

Examples

O exemplo a seguir mostra como remover todos os blocos de uma imagem 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

Gerencie a cor de fundo da imagem GIF com esta propriedade.Retire a cor de fundo para garantir a consistência e melhorar o apetite visual.

public override Color BackgroundColor { get; set; }

Valor da propriedade

Color

BackgroundColorIndex

Controle o índice de cor de fundo da imagem GIF usando esta propriedade.retire o índice para manter a consistência ou alcançar os efeitos visuais desejados.

public byte BackgroundColorIndex { get; set; }

Valor da propriedade

byte

Blocks

Obtenha acesso aos blocos de GIF sem fio com esta propriedade, facilitando facilmenterecuperação e manipulação das estruturas de dados subjacentes da imagem.

public IGifBlock[] Blocks { get; }

Valor da propriedade

IGifBlock [ ]

FileFormat

Retirar o formato de arquivo sem esforço com esta propriedade.para identificar o formato dos seus arquivos. integrados sem problemas no seu fluxo de trabalho,Ele fornece informações vitais sem qualquer engano.

public override FileFormat FileFormat { get; }

Valor da propriedade

FileFormat

HasBackgroundColor

Esta propriedade determina se a imagem GIF contém uma cor de fundo.verdade, indica que a imagem inclui uma cor de fundo.

public override bool HasBackgroundColor { get; }

Valor da propriedade

bool

HasTrailer

Gerencie a presença de um trailer em seus arquivos GIF com esta propriedade.precisa verificar se um trailer existe ou definir a sua presença, esta propriedade simplifica aMantenha seus arquivos GIF estruturados e conformes com esta funcionalidade intuitiva.

public bool HasTrailer { get; set; }

Valor da propriedade

bool

HasTransparentColor

Determine se o quadro ativo da imagem GIF inclui uma cor transparente.Esta propriedade fornece uma maneira conveniente de verificar a transparência dentro da imagem.

public override bool HasTransparentColor { get; set; }

Valor da propriedade

bool

ImageOpacity

Retirar a opacidade do quadro ativo dentro da imagem, oferecendo uma visãoseu nível de transparência. esta propriedade é particularmente útil para entender ograu de transparência ou opacidade do quadro ativo na imagem.

public override float ImageOpacity { get; }

Valor da propriedade

float

IsInterlaced

Determina se a imagem é interligada, afetando sua exibição durante o carregamento.A propriedade oferece uma visão do comportamento de renderização da imagem, essencial paraOtimizar estratégias de carregamento e melhorar a experiência de visualização geral.

public bool IsInterlaced { get; }

Valor da propriedade

bool

IsPaletteSorted

Controle a classificação da paleta em suas imagens GIF usando esta propriedade.Você precisa verificar se a paleta é classificada ou definir o comportamento de classificação, esteA propriedade fornece uma maneira simples de gerenciar a organização de paletes em seuarquivos GIF.

public bool IsPaletteSorted { get; set; }

Valor da propriedade

bool

LoopsCount

Retirar o número de loop sem esforço com esta propriedade. se sua imagem GIF incluiinformações de loop, esta propriedade lhe dá acesso rápido ao cálculo de loop, permitindoVocê pode gerenciar o comportamento de looping em seus arquivos GIF.

public int LoopsCount { get; set; }

Valor da propriedade

int

PageCount

Retirar o número total de páginas contidas na imagem com estePropriedade simples. ideal para avaliar rapidamente a extensão do conteúdo da imagem.

public override int PageCount { get; }

Valor da propriedade

int

Pages

Obtenha acesso às páginas dentro da imagem através desta propriedade conveniente,permitindo a navegação e a manipulação de páginas individuais, conforme necessário.

public override Image[] Pages { get; }

Valor da propriedade

Image [ ]

PaletteColorResolutionBits

Gerencie a resolução de cor de paleta de suas imagens GIF com esta propriedade.o número de bits usados para representar cores na paleta, fornecendo controle finosobre a profundidade da cor e a qualidade da imagem.

public byte PaletteColorResolutionBits { get; set; }

Valor da propriedade

byte

PixelAspectRatio

Gerencie a relação de aspecto do pixel da imagem GIF com esta propriedade.proporção de aspecto para garantir a realização exata e manter a fidelidade visual.

public byte PixelAspectRatio { get; set; }

Valor da propriedade

byte

TransparentColor

Retire a cor transparente do quadro ativo na imagem GIF. Esta propriedadepermite o acesso à cor específica que foi designada como transparentedentro do quadro atualmente ativo.

public override Color TransparentColor { get; }

Valor da propriedade

Color

XmpData

Gerencie metadados XMP com esta propriedade. se você está recuperando metadados existentesou atualizá-lo com novas informações, esta propriedade simplifica o processo.seus metadados organizados e acessíveis, garantindo que os seus arquivos contêminformações relevantes que precisam.

public override XmpPacketWrapper XmpData { get; set; }

Valor da propriedade

XmpPacketWrapper

Methods

AddBlock(Avaliação do IGIFBlock)

Adicionar um novo bloco GIF permite que você inclua dados adicionais na imagem.Este método permite que você adicione blocos personalizados à imagem GIF, que podeContém vários tipos de informação.

public void AddBlock(IGifBlock block)

Parameters

block IGifBlock

O bloco GIF para adicionar.

Examples

O exemplo a seguir mostra como compilar uma imagem GIF animada de blocos GIF individuais.

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 uma nova página sem fio na imagem existente, melhorando seu conteúdoe expandir o seu alcance. este método aumenta as coleções de imagens com maisConteúdo, fomentando a criatividade e a flexibilidade na gestão da imagem e composição.

public void AddPage(RasterImage page)

Parameters

page RasterImage

Página para adicionar.

Examples

Crie uma imagem GIF multipágina usando imagens de raster de página única.

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 a brilho da imagem de acordo com o parâmetro de brilho especificado. este método modifica a brilho da imagem inteira uniformemente, melhorando ou reduzindo a luminância geral para alcançar o efeito desejado.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Valor de brilho.

Examples

O exemplo a seguir executa a correção de brilho de uma imagem 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(Flotação)

Ajuste o contraste da imagem, melhorando ou reduzindo a diferença embrilho entre pixels. este método altera o alcance total de tonal da imagem,Fazer áreas escuras mais escuras e áreas mais brilhantes para melhorar a clareza visuale os detalhes.

public override void AdjustContrast(float contrast)

Parameters

contrast float

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

Examples

O exemplo seguinte realiza a correção de contraste de uma imagem 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

Não pode mudar o contraste. índice de frame: " + frameIndex

AdjustGamma(Flotação)

Melhorar a qualidade da imagem através da aplicação de correção gamma. este método ajusta a corgama da imagem para alcançar a clareza visual óptima. Modifica o valor da gamade cada pixel, resultando em uma melhor rendição de cores e aparência geral da imagem.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma para os canais vermelho, verde e azul coeficiente

Examples

O exemplo a seguir é a correção gamma de uma imagem 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(Flotas, Flotas e Flotas)

A correção de gama de uma imagem aplica uma adaptação não linear aos valores de pixel,melhorar ou reduzir a brilho com base nos coeficientes especificados para o vermelho;verde, e os canais azuis. este método ajuda a limpar o equilíbrio de cores eluminância da imagem, melhorando a sua aparência geral e qualidade visual.

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

Parameters

gammaRed float

Gamma para o Coeficiente de Canais Vermelhos

gammaGreen float

Gamma para o coeficiente de canais verdes

gammaBlue float

Gamma para o coeficiente de canais azuis

Examples

O exemplo a seguir realiza a correção gamma de uma imagem GIF aplicando coeficientes diferentes para os componentes de cor.

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(Dupla)

Binarização de uma imagem usando o algoritmo de limite adaptativo de Bradley comO limite de imagem integral é um método para converter uma imagem de grayscale emEste algoritmo calcula um limiar local para cada pixel com base ema intensidade média dos pixels circundantes dentro de uma janela especificada.adaptativamente ajustando o limiar com base nas intensidades de pixel locais, oO método é eficaz em lidar com variações na iluminação e contraste em toda a imagem.

public override void BinarizeBradley(double brightnessDifference)

Parameters

brightnessDifference double

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

BinarizeFixed(em byte)

Binarização de uma imagem com um limite predefinido converte uma escada cinza ou corimagem em uma imagem binária, onde cada pixel é classificado como preto ou brancodependendo se o seu valor de intensidade excede um limiar especificado.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

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

Examples

O exemplo a seguir binariza uma imagem GIF com o limite predefinido. imagens binárias contêm apenas 2 cores - preto e branco.

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

Binarização de uma imagem com o limite Otsu é um método usado paradeterminar o valor-limite ideal para a conversão de uma imagem de graus em umaO algoritmo de limite do Otsu calcula o limite queminimizar a variação intra-classe das intensidades de pixel nos dois resultadosclasses (foreground e background). esta técnica é particularmente útil quandoO valor-limite ideal é desconhecido e deve ser determinado de forma adaptativa.no histograma da imagem.

public override void BinarizeOtsu()

Examples

O exemplo a seguir binariza uma imagem GIF com o limite Otsu. imagens binárias contêm apenas 2 cores - preto e branco.

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

A limpeza de todos os blocos GIF remove todos os dados existentes armazenados na imagem.Esta operação efetivamente retorna a imagem a um estado vazio, removendo qualquerblocos adicionados anteriormente. use este método quando você precisa começar fresco com umpara criar ou modificar uma imagem GIF.

public void ClearBlocks()

Examples

O exemplo a seguir mostra como remover todos os blocos de uma imagem 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 a imagem usando uma área rectangular especificada. esta operação remove o exteriorporção da imagem, deixando apenas a região selecionada definida pelo rectangulo.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

do rectangulo.

Examples

O exemplo a seguir colhe uma imagem GIF. A área de colheita é especificada atravé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)

Aplique o dithering para a imagem atual. Este processo melhora a qualidade da imagem porReduzir a ligação de cores e melhorar as transições de cores, resultando em uma mais suaveaparência .

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

Parameters

ditheringMethod DitheringMethod

Metodologia do Dilúvio.

bitsCount int

Os bits finais contam para dithering.

customPalette IColorPalette

A paleta custom para dithering.

Examples

O exemplo a seguir carrega uma imagem GIF e realiza o limite e fluxo de dithering usando 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 um filtro específico à área designada da imagem, melhorando a sua visãoqualidade ou alterar a sua aparência como desejado. este método seletivamente processapixels dentro do rectangulo definido, permitindo que os ajustes direcionados sejam feitosAo mesmo tempo, preservar a integridade dos dados de imagem circundantes.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

do rectangulo.

options FilterOptionsBase

As opções .

Examples

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

Retirar as opções baseadas em configurações de arquivo originais, cruciais para manter a fidelidadee consistência no processamento de imagem e manipulação. este método permite semintegração de parâmetros específicos de arquivo em operações subsequentes, assegurandorendimento preciso e aderência às características inerentes da imagem.Isso pode ser útil para manter a profundidade do bit e outros parâmetros da imagem original inalterados.Por exemplo, se carregarmos uma imagem PNG de preto e branco com 1 bit por pixel e, em seguida, salvá-la usando oAspose.Imaging.DataStreamSupporter.Save(System.String) método, a imagem PNG de saída com 8 bits por pixel será produzida.Para evitar isso e salvar a imagem PNG com 1 bits por pixel, use este método para obter opções de poupança correspondentes e passá-laspara o método Aspose.Imaging.Image.Save(System.String,Aspose.Imaging.ImageOptionsBase) como o segundo parâmetro.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

As opções baseadas nas configurações de arquivo originais.

Grayscale()

A transformação de uma imagem em sua representação cinza converte a corImagem em uma versão de escala cinza, removendo informações de cor enquanto preservandoEste processo simplifica a imagem para sombras de cinza, tornando-a adequadapara várias aplicações, como impressão, processamento de documentos e grayscaleda análise.

public override void Grayscale()

Examples

O exemplo a seguir transforma uma imagem de GIF colorida em sua representação de grayscale. imagens de grayscale são compostas exclusivamente de sombras de cinza e carregam apenas informações de intensidade.

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)

A inserção de um novo bloco GIF permite que você adicione dados personalizados em uma posição específicadentro da imagem. este método permite que você coloque blocos personalizados em um desejolocalização na imagem GIF, proporcionando flexibilidade na organização e estruturação dadados da imagem.

public void InsertBlock(int index, IGifBlock block)

Parameters

index int

O elemento baseado em zero, no qual o bloco será inserido.

block IGifBlock

O bloco GIF para adicionar.

OnPaletteChanged(Coloração, Coloração, Coloração)

Chamado quando a paleta é mudada.

protected override void OnPaletteChanged(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

A velha paleta.

newPalette IColorPalette

A nova paleta.

OnPaletteChanging(Coloração, Coloração, Coloração)

Chamada quando a paleta está mudando.

protected override void OnPaletteChanging(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

A velha paleta.

newPalette IColorPalette

A nova paleta.

OrderBlocks()

Ordenar os blocos GIF de acordo com a especificação GIF garante o GIF adequadolayout e conformidade com o padrão. este processo envolve a organização doblocos na sequência correta, conforme definido pela especificação.pode envolver a remoção de certos Aspose.Imaging.FileFormats.Gif.Blocks.GifGraphicsControlBlock instâncias quenão são necessários para o layout final. Ao aderir à especificação GIF, oA imagem resultante será estruturada corretamente e compatível com a visualização GIFAplicações .

public void OrderBlocks()

RemoveBlock(Avaliação do IGIFBlock)

Remover um bloco GIF remove dados específicos da imagem, oferecendo a capacidade delimpar ou modificar a estrutura da imagem. este método permite que você remova o indesejadoou blocos desnecessários, otimizando a imagem GIF para armazenamento eficiente.Funcionalidade para eliminar informações obsoletas da imagem enquanto preservandosua integridade e qualidade.

public void RemoveBlock(IGifBlock block)

Parameters

block IGifBlock

O bloco é removido.

Remarks

Observação: não se esqueça de dispor do bloco se você não adicioná-lo a algum outro GifImage.

Resize(Int, Int, ResizeType)

Recuperar este Aspose.Imaging.Image instância.

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

Parameters

newWidth int

A nova amplitude.

newHeight int

A nova altura.

resizeType ResizeType

O tipo de resgate.

Examples

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

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

Recuperar este Aspose.Imaging.Image instância.

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

Parameters

newWidth int

A nova amplitude.

newHeight int

A nova altura.

settings ImageResizeSettings

As configurações .

Examples

Este exemplo carrega uma imagem GIF e a resisa usando várias configurações de resisação.

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 a imagem, tendo em conta os quadros completos para cada página em umGIF, impedindo assim que possíveis artefatos aparecem. este método é essencialpara manter a integridade e a qualidade da imagem, especialmente quando se trata deGIFs animados ou sequências de quadros.

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

Parameters

newWidth int

A nova amplitude.

newHeight int

A nova altura.

resizeType ResizeType

O tipo de resgate.

ResizeProportional(Int, Int, ResizeType)

A ressuscitação proporcional mantém a proporção de aspecto da imagem ao ajustar o tamanho, garantindo que a imagem não pareça estendida ou distorcida.Este método ressuscita a imagem proporcionalmente, escalando tanto a largura quanto a altura pelo mesmo fator.A ressuscitação proporcional ressuscita cada quadro de acordo com a proporção de newWidth’/width e newHeight’/height.

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

Parameters

newWidth int

A nova amplitude.

newHeight int

A nova altura.

resizeType ResizeType

O tipo de resgate.

Rotate(Float, Bool, Coloração)

Este método rota a imagem em torno de seu ponto central. especificando a rotaçãoângulo, você pode rotar a imagem de modo relógio ou contra relógio para alcançar oorientação desejada. esta rotação ajuda a ajustar a apresentação da imagem ouAlinhamento sem distorcer o seu conteúdo.

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

Parameters

angle float

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

resizeProportionally bool

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

backgroundColor Color

A cor do fundo.

RotateFlip(RotateFlipType)

Realizar rotação, flipping, ou ambos no quadro ativo exclusivamente.aplica transformações exclusivamente ao atual quadro ativo da imagem,Preservar a integridade de outros quadros na sequência.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Tipo de flip rotativo.

Examples

Este exemplo carrega uma imagem GIF, a rota por 90 graus de olho e opcional flips a imagem horizontalmente e/ou 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)

Salve os dados.

protected override void SaveData(Stream stream)

Parameters

stream Stream

O fluxo para salvar dados para.

SetFrameTime(Acontece)

Ajusta a duração de cada quadro em milisecundos, garantindo um tempo consistentedurante toda a sequência da imagem. este método fixa uniformemente o tempo de exibição paracada quadro, permitindo um controle preciso sobre a velocidade da animação.A mudança deste valor retardará todos os quadros.

public void SetFrameTime(ushort time)

Parameters

time ushort

O tempo de duração do quadro em milisegundos.

UpdateDimensions(Int, Int)

Atualiza as dimensões da imagem.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

A nova imagem de largura.

newHeight int

O novo tamanho da imagem.

 Português