Class GifImage

Class GifImage

De naam: Aspose.Imaging.FileFormats.Gif Verzameling: Aspose.Imaging.dll (25.4.0)

De API voor Graphical Interchange Format (GIF) beeldbestand biedtontwikkelaars met veelzijdige tools voor het verwerken van gecomprimeerde rasterbeelden engeanimeerde GIF’s. aanbieden van functies zoals XMP metadata-behandeling, kleurpaletinstellingen, achtergrond en transparante kleurbeheersing, opaciteitssettings, resize,crop, filter applicatie, gamma correcties, contrast aanpassing, grayscaletransformatie, en conversie naar andere formaten. deze API vergemakkelijkt onbeperktmanipulatie en verbeteren van GIF-beelden voor een breed scala aan toepassingen.

[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

Geëerbiede leden

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

Export van een deel van de animatie uit GIF-afbeelding op basis van tijdinterval.

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

Dit voorbeeld laat zien hoe u een GIF-afbeelding kunt maken en het in een bestand kunt opslaan.

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

Creëren van meerdere GIF-afbeeldingen met behulp van een enkele pagina raster.

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

Stel een nieuw Aspose.Imaging.FileFormats.Gif. GifImage object met specifieke parameters voor deeerste frame en wereldwijde palet. start het beheren van GIF-afbeeldingen snel, waarborgennauwkeurige representatie met aangepaste instellingen voor optimale resultaten.

public GifImage(GifFrameBlock firstFrame, IColorPalette globalPalette)

Parameters

firstFrame GifFrameBlock

De eerste frame om gif-afbeelding met te initialiseren.

globalPalette IColorPalette

Houd er rekening mee dat als beide firstFrame’ en <code class=paramaf">globalPalette’ null zijn dan de standaard globale palette wordt gebruikt.

Examples

Dit voorbeeld laat zien hoe je een GIF-afbeelding kunt maken met een aangepaste palet en het in een bestand kunt opslaan.

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

De firstFrame’ kan niet nul zijn

ArgumentException

De firstFrame’ behoort al tot een ander beeld.

GifImageException

De globalPalette’ aangegeven moet entries tellen gelijk aan de kracht van 2.

GifImage(GifFrameBlock)

Het creëren van GIF-afbeeldingen wordt moeiteloos met de Aspose.Imaging.FileFormats.Gif.Constructor. met alleen de eersteFrame parameter, komt het in een wereld van dynamischeDe visuele communicatie.

public GifImage(GifFrameBlock firstFrame)

Parameters

firstFrame GifFrameBlock

De eerste frame om gif-afbeelding met te initialiseren.

Examples

Dit voorbeeld laat zien hoe u een GIF-afbeelding kunt maken en het in een bestand kunt opslaan.

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

Het volgende voorbeeld toont hoe je een geanimeerde GIF-afbeelding kunt composeren van individuele Gif-blocks.

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

De firstFrame’ kan niet nul zijn

ArgumentException

De firstFrame’ behoort al tot een ander beeld.

GifImageException

De gespecificeerde palet moet entries tellen gelijk aan de kracht van 2. minimale paletsgrootte is 2, maximale is 256.

GifImage(GifFrameBlock, IColorPalette, Bool, Byte, Bytes, byten, bool)

Begin zonder moeite met de Aspose.Imaging.FileFormats.Gif. GifImage constructor.eenvoudige methode, kunt u in het creëren van geanimeerde GIF’s gemakkelijk.firstFrame, globalPalette, paletteColorResolution, aspectRatio, en andereparameters, en je bent klaar om je visuelen naar het leven te brengen.

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

Parameters

firstFrame GifFrameBlock

De eerste frame om gif-afbeelding met te initialiseren.

globalPalette IColorPalette

Houd er rekening mee dat als beide firstFrame’ en <code class=paramaf">globalPalette’ null zijn dan de standaard globale palette wordt gebruikt.

isPaletteSorted bool

als je ’true’ hebt ingesteld, wordt de palet gesorteerd. merk op dat de parameter wordt gebruikt wanneer globalPalette" niet nul is.

paletteColorResolution byte

Noteer de parameter wordt gebruikt wanneer globalPalette’ niet nul is.

paletteBackgroundColorIndex byte

De palet achtergrond kleur index.

aspectRatio byte

Het aspect ratio.

hasTrailer bool

als de gif-afbeelding ‘waar’ is vastgesteld, heeft de trailer anders geen trailer geschreven aan het einde van de stroom.

Exceptions

ArgumentNullException

De firstFrame’ kan niet nul zijn

ArgumentException

De firstFrame’ behoort al tot een ander beeld.

GifImageException

De globalPalette’ aangegeven moet entries tellen gelijk aan de kracht van 2.

Properties

ActiveFrame

Het beheren en manipuleren van kaders met deze eigenschap, waardoor een gladde navigatie enwijziging van het actieve kader binnen de GIF-afbeelding.

public GifFrameBlock ActiveFrame { get; set; }

Eigendomswaarde

GifFrameBlock

Examples

Het volgende voorbeeld laat zien hoe je alle blokken van een GIF-afbeelding kunt verwijderen.

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

beheer de achtergrondkleur van de GIF-afbeelding met deze eigenschap.herhalen van de achtergrondkleur om consistentie te garanderen en visueel aantrekkingskracht te verbeteren.

public override Color BackgroundColor { get; set; }

Eigendomswaarde

Color

BackgroundColorIndex

Controleer de achtergrondkleurindex van de GIF-afbeelding met behulp van deze eigenschap.herstellen van de index om consistentie te behouden of gewenste visuele effecten te bereiken.

public byte BackgroundColorIndex { get; set; }

Eigendomswaarde

byte

Blocks

Krijg toegang tot de GIF-blocks met deze eigenschap, waardoor het gemakkelijk isherstel en manipulatie van de onderliggende gegevensstructuren van het beeld.

public IGifBlock[] Blocks { get; }

Eigendomswaarde

IGifBlock []

FileFormat

Herstel het bestandformaat moeiteloos met deze eigenschap. het is uw go-to sourceom het formaat van uw bestanden te identificeren. onlosmakelijk geïntegreerd in uw werkstroom,Het verstrekt vitale informatie zonder enige hassel.

public override FileFormat FileFormat { get; }

Eigendomswaarde

FileFormat

HasBackgroundColor

Deze eigenschap bepaalt of de GIF-afbeelding een achtergrondkleur bevat.waar, het geeft aan dat de afbeelding een achtergrondkleur bevat.

public override bool HasBackgroundColor { get; }

Eigendomswaarde

bool

HasTrailer

beheer de aanwezigheid van een trailer in uw GIF-bestanden met deze eigenschap.moet worden gecontroleerd of een trailer bestaat of de aanwezigheid ervan wordt ingesteld, deze eigenschap vergemakkelijkt deHoud uw GIF-bestanden gestructureerd en in overeenstemming met deze intuïtieve functie.

public bool HasTrailer { get; set; }

Eigendomswaarde

bool

HasTransparentColor

Bepaal of het actieve kader van de GIF-afbeelding een transparante kleur bevat.Deze woning biedt een handige manier om de transparantie binnen het beeld te controleren.

public override bool HasTransparentColor { get; set; }

Eigendomswaarde

bool

ImageOpacity

Verwijder de opaciteit van het actieve kader binnen de afbeelding, met inzicht inhet niveau van transparantie. deze eigendom is bijzonder nuttig voor het begrijpen van dede mate van transparantie of onduidelijkheid van het actieve kader in het beeld.

public override float ImageOpacity { get; }

Eigendomswaarde

float

IsInterlaced

Het bepaalt of de afbeelding is ingesloten, wat zijn display tijdens het opladen beïnvloedt.eigendom biedt inzicht in het renderende gedrag van het beeld, essentieel voorhet optimaliseren van loadingstrategieën en het vergroten van de algemene kijkervaring.

public bool IsInterlaced { get; }

Eigendomswaarde

bool

IsPaletteSorted

Controleer de sortering van de palet in uw GIF-afbeeldingen met behulp van deze eigenschap. ofu moet controleren of de palet is gesorteerd of het sortering gedrag instellen, diteigendom biedt een eenvoudige manier om de paletorganisatie in uwGIF bestanden.

public bool IsPaletteSorted { get; set; }

Eigendomswaarde

bool

LoopsCount

Verwijder de loop count moeiteloos met deze eigenschap. als uw GIF-afbeelding bevatloopinformatie, deze eigenschap geeft u snelle toegang tot de loop count, waardoorU kunt het loopgedrag in uw GIF-bestanden onbeperkt beheren.

public int LoopsCount { get; set; }

Eigendomswaarde

int

PageCount

Verwijder het totale aantal pagina’s in de afbeelding met ditideaal voor snelle beoordeling van de omvang van het beeldinhoud.

public override int PageCount { get; }

Eigendomswaarde

int

Pages

Het verkrijgen van toegang tot de pagina’s binnen de afbeelding door middel van deze handige eigendom,het mogelijk maken om naadloos te navigeren en te manipuleren van individuele pagina’s als nodig.

public override Image[] Pages { get; }

Eigendomswaarde

Image []

PaletteColorResolutionBits

beheer de kleurresolutie van uw GIF-afbeeldingen met deze eigenschap.het aantal bits dat wordt gebruikt om kleuren in de palet te vertegenwoordigen, waardoor een fijne controleOver kleur diepte en beeldkwaliteit.

public byte PaletteColorResolutionBits { get; set; }

Eigendomswaarde

byte

PixelAspectRatio

Beheer het pixel aspectpercentage van de GIF-afbeelding met deze eigenschap.de aspectverhouding om nauwkeurige rendering te garanderen en visuele trouw te behouden.

public byte PixelAspectRatio { get; set; }

Eigendomswaarde

byte

TransparentColor

Verwijder de transparante kleur van het actieve frame in de GIF-afbeelding.U kunt toegang krijgen tot de specifieke kleur die als transparant is aangeduid.binnen het huidige actieve kader.

public override Color TransparentColor { get; }

Eigendomswaarde

Color

XmpData

XMP metadata beheren met deze eigenschap. of u bestaande metgegevens opneemtof het bijwerken met nieuwe informatie, deze eigenschap vergemakkelijkt het proces.uw metadata georganiseerd en toegankelijk, zodat uw bestanden derelevante informatie die ze nodig hebben.

public override XmpPacketWrapper XmpData { get; set; }

Eigendomswaarde

XmpPacketWrapper

Methods

AddBlock(De IGIFBlock)

Door een nieuwe GIF-blok toe te voegen, kunt u extra gegevens in de afbeelding opnemen.Deze methode maakt het mogelijk om aangepaste blokken aan de GIF-afbeelding toe te voegen, dieHet bevat verschillende soorten informatie.

public void AddBlock(IGifBlock block)

Parameters

block IGifBlock

De GIF blok om toe te voegen.

Examples

Het volgende voorbeeld toont hoe je een geanimeerde GIF-afbeelding kunt composeren van individuele Gif-blocks.

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)

Incorporeren van een nieuwe pagina naadloos in de bestaande afbeelding, waardoor de inhoud ervan wordt verbeterden het uitbreiden van zijn bereik. deze methode vergroot beeldverzamelingen met extracontent, het bevorderen van creativiteit en flexibiliteit in beeldmanagement en compositie.

public void AddPage(RasterImage page)

Parameters

page RasterImage

De pagina om toe te voegen.

Examples

Creëren van meerdere GIF-afbeeldingen met behulp van een enkele pagina raster.

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)

Deze methode wijzigt de helderheid van het hele beeld uniform, verbetert of vermindert de algemene luminositeit om het gewenste effect te bereiken.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

De briljante waarde.

Examples

Het volgende voorbeeld uitvoert de helderheidcorrectie van een GIF-afbeelding.

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

Aanpast het contrast van de afbeelding, verbetert of vermindert het verschil inhelderheid tussen pixels. deze methode wijzigt het totale tonalbereik van de afbeelding,donkere gebieden donkerder maken en helderder gebied versterken om de visuele duidelijkheid te verbeterenEn de details.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Contrastwaarde (in bereik [-100; 100])

Examples

Het volgende voorbeeld uitvoert een contrastcorrectie van een GIF-afbeelding.

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

Kan het contrast niet veranderen. frame index: " + frameIndex

AdjustGamma(Vloot)

Verbeteren van de beeldkwaliteit door gamma-correctie toe te passen. deze methode regelt de kleurgamma van het beeld om optimale visuele duidelijkheid te bereiken. het verandert de gamma-waardevan elk pixel, wat resulteert in een verbeterde kleur renditie en de algemene afbeelding.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma voor rode, groene en blauwe kanalen coëfficiënt

Examples

Het volgende voorbeeld uitvoert een gamma-correctie van een GIF-afbeelding.

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(De vloot, de vloot, de vloot)

Gamma-correctie van een afbeelding geldt voor een niet-lineaire aanpassing aan de pixelwaarden,verbeteren of verminderen van helderheid op basis van de aangegeven coëfficiënten voor rood,groen, en blauw kanalen. deze methode helpt om de kleurbalans enverlichting van het beeld, het verbeteren van zijn algemene uiterlijk en visuele kwaliteit.

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

Parameters

gammaRed float

Gamma voor de rode kanaal coefficiënt

gammaGreen float

Gamma voor groene kanaal coëfficiënt

gammaBlue float

Gamma voor blauw kanaal coefficiënt

Examples

Het volgende voorbeeld uitvoert een gamma-correctie van een GIF-afbeelding die verschillende coëfficiënten toepast op kleurcomponenten.

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

Binarisatie van een afbeelding met behulp van Bradley’s adaptieve thresholding algoritmeintegrale beeldgrenzen is een methode voor het omzetten van een grayscale afbeelding in eenDeze algoritme berekent een lokale drempel voor elke pixel op basis vande gemiddelde intensiteit van de omringende pixels binnen een bepaald venster.adaptieve aanpassing van de drempel op basis van lokale pixelintensiteiten, Bradley’sDe methode is effectief bij het omgaan met variaties in verlichting en contrast over de afbeelding.

public override void BinarizeBradley(double brightnessDifference)

Parameters

brightnessDifference double

Het lichtverschil tussen de pixel en het gemiddelde van een s x s venster van pixels centraal rond deze pixel.

BinarizeFixed(byte)

Binarisatie van een afbeelding met een vooraf gedefinieerde drempel converteert een grijze schaal of kleurbeeld in een binaire beeld, waar elk pixel wordt geclassificeerd als zwart of witafhankelijk van of de intensiteitswaarde een bepaalde drempel overschrijdt.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Als de overeenkomstige grijze waarde van een pixel groter is dan de grens, wordt er een waarde van 255 aan toegewezen, 0 anders.

Examples

Het volgende voorbeeld binarisert een GIF-afbeelding met de vooraf gedefinieerde drempel. Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.

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

Binarisatie van een afbeelding met Otsu thresholding is een methode die wordt gebruikt om automatischde optimale grenswaarde te bepalen voor het omzetten van een grayscale afbeelding in eenHet Otsu-grensalgoritme berekent de grens dieminimaliseren de intra-klasse variatie van de pixelintensiteiten in de twee resulterendeklassen (voorgrond en achtergrond). deze techniek is bijzonder nuttig wanneerde optimale grenswaarde is onbekend en moet op adaptieve basis worden vastgesteld.op het histogram van de afbeelding.

public override void BinarizeOtsu()

Examples

Het volgende voorbeeld binarisert een GIF-afbeelding met Otsu thresholding. Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.

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

Het verwijderen van alle GIF-blocks verwijdert alle bestaande gegevens die in de afbeelding zijn opgeslagen.Deze operatie herstelt de afbeelding doeltreffend in een leeg toestand en verwijdert alleeerder toegevoegde blokken. gebruik deze methode wanneer u moet beginnen vers met een schoneSlate om een GIF-afbeelding te maken of te wijzigen.

public void ClearBlocks()

Examples

Het volgende voorbeeld laat zien hoe je alle blokken van een GIF-afbeelding kunt verwijderen.

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)

Groeien de afbeelding met behulp van een bepaald rectangle gebied. deze operatie verwijdert de buitenkantdeel van de afbeelding, verlaten alleen de geselecteerde regio gedefinieerd door de rectangle.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

De rechthoek.

Examples

Het volgende voorbeeld verzamelt een GIF-afbeelding. het vergrendelingsgebied wordt aangegeven via 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(DitheringMethod, int, IColorPalette)

Dit proces verbetert de kwaliteit van de afbeelding doorverminderen van kleurbanding en verbeteren kleuroverschrijvingen, wat resulteert in een gladderHet uiterlijk.

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

Parameters

ditheringMethod DitheringMethod

De Dithering Methode.

bitsCount int

De laatste bits tellen voor dithering.

customPalette IColorPalette

De gewone palet voor dithering.

Examples

Het volgende voorbeeld loopt een GIF-afbeelding en uitvoert grenzen en vloeibare dithering met behulp van verschillende paletdichtheid.

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)

Gebruik een specifiek filter op het aangewezen gebied van de afbeelding, waardoor het visuelekwaliteit of wijzigen van zijn uiterlijk zoals gewenste. deze methode selectief verwerktpixels binnen de gedefinieerde rectangle, waardoor gericht aanpassingen kunnen worden gedaande integriteit van de omliggende beeldgegevens te behouden.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

De rechthoek.

options FilterOptionsBase

De opties .

Examples

Het volgende voorbeeld geldt voor verschillende soorten filters voor een GIF-afbeelding.

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

Herstellen van de oorspronkelijke bestandinstellingen-gebaseerde opties, cruciaal voor het behouden van loyaliteiten consistentie in beeldverwerking en manipulatie. deze methode maakt het mogelijkde integratie van bestandspecifieke parameters in latere operaties, waarborgennauwkeurige aflevering en naleving van de inherente kenmerken van het beeld.Dit kan nuttig zijn om bit-diepte en andere parameters van de oorspronkelijke afbeelding onveranderd te houden.Bijvoorbeeld, als we een zwarte en witte PNG-afbeelding opladen met 1 bit per pixel en dan het opslaan met behulp van deAspose.Imaging.DataStreamSupporter.Save(System.String) methode, de output PNG-afbeelding met 8 bits per pixel zal worden geproduceerd.Om dit te voorkomen en PNG-afbeelding met 1 bits per pixel te besparen, gebruik deze methode om de overeenkomstige besparingsopties te krijgen en ze te passeren.De methode Aspose.Imaging.Image.Save(System.String,_Wl17. ImageOptionsBase) is de tweede parameter.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

De opties gebaseerd op de oorspronkelijke bestandinstellingen.

Grayscale()

De transformatie van een afbeelding naar zijn grayscale vertegenwoordiging converteert de kleurafbeelding in een grayscale versie door kleurinformatie te verwijderen terwijlDit proces vereenvoudigt de afbeelding tot schaduwen van grijze, waardoor het geschikt isvoor verschillende toepassingen zoals afdrukken, documentverwerking en grayscaleDe analyse.

public override void Grayscale()

Examples

Het volgende voorbeeld verandert een gekleurde GIF-afbeelding in zijn grayscale-representatie. Grayscal-foto’s zijn uitsluitend samengesteld uit schaduwen van grijze en dragen alleen informatie over intensiteit.

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(Het is IGIFBlock)

Door een nieuwe GIF-blok in te voegen, kunt u aangepaste gegevens toevoegen aan een specifieke locatie.binnen de afbeelding. deze methode stelt u in staat om aangepaste blokken te plaatsen op een gewenstelocatie in de GIF-afbeelding, die flexibiliteit biedt bij het organiseren en structureren van deafbeeldingsgegevens .

public void InsertBlock(int index, IGifBlock block)

Parameters

index int

Het nulgebaseerde element, waarop het blok zal worden ingebouwd.

block IGifBlock

De GIF blok om toe te voegen.

OnPaletteChanged(Hoofdstukken van IColorPalette)

Het wordt genoemd wanneer de palet wordt gewijzigd.

protected override void OnPaletteChanged(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

De oude palet.

newPalette IColorPalette

De nieuwe palet.

OnPaletteChanging(Hoofdstukken van IColorPalette)

Het wordt genoemd wanneer de palet verandert.

protected override void OnPaletteChanging(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

De oude palet.

newPalette IColorPalette

De nieuwe palet.

OrderBlocks()

Het bestellen van de GIF-blocks overeenkomstig de specifiekte van het Gif zorgt voor de juiste gIF.ontwerp en naleving van de standaard. dit proces houdt in dat deblokken in de juiste volgorde zoals gedefinieerd door de specificatie.kan leiden tot het verwijderen van bepaalde Aspose.Imaging.FileFormats.Gif.Blocks. GifGraphicsControlBlock instanties dieniet noodzakelijk voor de definitieve layout. door aan de GIF-specificatie te voldoen, dede resulterende afbeelding zal correct gestructureerd en compatibel zijn met GIF-visualisatieAanvragen .

public void OrderBlocks()

RemoveBlock(De IGIFBlock)

Het verwijderen van een GIF-blok verwijdert specifieke gegevens uit de afbeelding en biedt de mogelijkheid omreinigen of wijzigen van de beeldstructuur. deze methode stelt u in staat om ongewenste te verwijderenof onnodige blokken, het optimaliseren van de GIF-afbeelding voor efficiënte opslag.functionaliteit om verouderde informatie uit de afbeelding te verwijderen terwijl hetZijn integriteit en kwaliteit.

public void RemoveBlock(IGifBlock block)

Parameters

block IGifBlock

De blok om te verwijderen.

Remarks

Opmerking: vergeet niet om het blok te plaatsen als u het niet toevoegt aan een andere GifImage.

Resize(int, int, resizeType)

herstelt dit Aspose.Imaging.Image instantie.

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

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

resizeType ResizeType

De resize type.

Examples

Dit voorbeeld loopt een GIF-afbeelding en resiseert het met behulp van verschillende resizingmethoden.

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)

herstelt dit Aspose.Imaging.Image instantie.

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

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

settings ImageResizeSettings

De instellingen .

Examples

Dit voorbeeld laden een GIF-afbeelding op en resiseert het met behulp van verschillende resizing-instellingen.

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)

Het herstellen van de afbeelding terwijl rekening wordt gehouden met de volledige kaders voor elke pagina in eenGIF, waardoor potentiële artefacten niet verschijnen. deze methode is essentieelom de integriteit en kwaliteit van het beeld te behouden, met name bij het omgaan metgeanimeerde GIF’s of sequenties van frames.

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

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

resizeType ResizeType

De resize type.

ResizeProportional(int, int, resizeType)

Proportionele resisatie houdt het aspectverhouding van het beeld bij het aanpassen van de grootte ervan, zodat de afbeelding niet uitgestrekt of vervormd lijkt.Deze methode resiseert het image proportioneel, scaleert zowel de breedte als de hoogte door dezelfde factor.De proportional resize zal elk frame resimeren volgens het ratio van newWidth’/width en newHeight’ / height.

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

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

resizeType ResizeType

De resize type.

Rotate(Float, bool, kleur)

Deze methode draait het beeld rond zijn centraal punt. door de rotatie te specificerenhoek, kunt u de afbeelding horloge of counterhoek roteren om deDeze rotatie helpt de presentatie van de afbeelding aan te passen ofaanpassing zonder de inhoud ervan te verstoord.

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

Parameters

angle float

De rotatie van de hoek in graden. positieve waarden zullen rotatie horloge.

resizeProportionally bool

als je ’true’ hebt ingesteld, zal je afbeeldingsgrootte worden gewijzigd, afhankelijk van rotatie rectangle (kornpunten) projecties in andere gevallen die de dimensies niet aanraken en alleen interne beeldinhoud wordt roterd.

backgroundColor Color

De kleur van de achtergrond.

RotateFlip(RotateFlipType)

Doen rotatie, flipping, of beide op het actieve frame uitsluitend.de transformaties alleen toe te passen aan het huidige actieve kader van de afbeelding,behoud van de integriteit van andere kaders in de sequentie.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

De rotated flip type.

Examples

Dit voorbeeld laden een GIF-afbeelding op, draait het met 90 graden horloge en flipt optioneel het beeld horizontaal en/of verticaal.

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)

Bespaar de gegevens.

protected override void SaveData(Stream stream)

Parameters

stream Stream

De stroom om gegevens op te slaan.

SetFrameTime(Wouten)

Het regelt de duur van elk frame in milliseconden, waardoor consistent timing wordt gewaarborgd.gedurende de afbeeldingssectie. deze methode bepaalt uniform de displaytijd voorelke frame, waardoor nauwkeurige controle over de animatie snelheid mogelijk is.Het wijzigen van deze waarde zal de vertraging voor alle kaders herstellen.

public void SetFrameTime(ushort time)

Parameters

time ushort

De tijd van de frame duur in milliseconden.

UpdateDimensions(int, int)

Update de afbeeldingsdimensies.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

De nieuwe beeldbreedte.

newHeight int

De nieuwe beeldhoogte.

 Nederlands