Class WebPOptions

Class WebPOptions

Namespace: Aspose.Imaging.ImageOptions
Assembly: Aspose.Imaging.dll (25.2.0)

Create modern WebP raster web images using our API, featuring robust support for lossless and lossy compression, as well as alpha channels and animation loops. Enhance your web content with dynamic visuals while optimizing file sizes for improved loading speeds and user experience.

[JsonObject(MemberSerialization.OptIn)]
public class WebPOptions : ImageOptionsBase, IDisposable, IHasXmpData, IHasMetadata, ICloneable

Inheritance

objectDisposableObjectImageOptionsBaseWebPOptions

Implements

IDisposable, IHasXmpData, IHasMetadata, ICloneable

Inherited Members

ImageOptionsBase.Clone(), ImageOptionsBase.ReleaseManagedResources(), ImageOptionsBase.KeepMetadata, ImageOptionsBase.XmpData, ImageOptionsBase.Source, ImageOptionsBase.Palette, ImageOptionsBase.ResolutionSettings, ImageOptionsBase.VectorRasterizationOptions, ImageOptionsBase.BufferSizeHint, ImageOptionsBase.MultiPageOptions, ImageOptionsBase.FullFrame, ImageOptionsBase.ProgressEventHandler, DisposableObject.Dispose(), DisposableObject.ReleaseManagedResources(), DisposableObject.ReleaseUnmanagedResources(), DisposableObject.VerifyNotDisposed(), DisposableObject.Disposed, object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Examples

This example shows how to create a WebP image from another raster image with different compression quality.```csharp [C#]

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

                                                                                                                  // Load a GIF animation
                                                                                                                  using (Aspose.Imaging.Image image = new Aspose.Imaging.Image.Load(dir + "test.gif"))
                                                                                                                  {
                                                                                                                      // for lossless compression, increasing the quality setting increases the compression quality and decreases the file size
                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_20.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 20 }); // file size: 42 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_50.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 50 }); // file size: 41 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_80.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 80 }); // file size: 40 KB


                                                                                                                      // for lossy compression, increasing the Quality value increases the image quality and increases the file size
                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_20.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 20 }); // file size: 24 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_50.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 50 }); // file size: 36 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_80.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 80 }); // file size: 51 KB
                                                                                                                  }

The following example shows how to convert a multipage vector image to WEBP format in general way without referencing to a particular image type.```csharp
[C#]

                                                                                                                                                            string dir = "C:\\aspose.imaging\\net\\misc\\ImagingReleaseQATester\\Tests\\testdata\\2548";
                                                                                                                                                            string inputFilePath = System.IO.Path.Combine(dir, "Multipage.cdr");
                                                                                                                                                            string outputFilePath = System.IO.Path.Combine(dir, "Multipage.cdr.webp");

                                                                                                                                                            Aspose.Imaging.ImageOptionsBase exportOptions = new Aspose.Imaging.ImageOptions.WebPOptions();

                                                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(inputFilePath))
                                                                                                                                                            {
                                                                                                                                                                exportOptions.MultiPageOptions = null;

                                                                                                                                                                // Export only first two pages. These pages will be presented as animated frames in the output WEBP.
                                                                                                                                                                Aspose.Imaging.IMultipageImage multipageImage = image as Aspose.Imaging.IMultipageImage;
                                                                                                                                                                if (multipageImage != null && (multipageImage.Pages != null && multipageImage.PageCount > 2))
                                                                                                                                                                {
                                                                                                                                                                    exportOptions.MultiPageOptions = new Aspose.Imaging.ImageOptions.MultiPageOptions(new Aspose.Imaging.IntRange(0, 2));
                                                                                                                                                                }

                                                                                                                                                                if (image is Aspose.Imaging.VectorImage)
                                                                                                                                                                {
                                                                                                                                                                    exportOptions.VectorRasterizationOptions = (Aspose.Imaging.ImageOptions.VectorRasterizationOptions)image.GetDefaultOptions(new object[] { Aspose.Imaging.Color.White, image.Width, image.Height });
                                                                                                                                                                    exportOptions.VectorRasterizationOptions.TextRenderingHint = Aspose.Imaging.TextRenderingHint.SingleBitPerPixel;
                                                                                                                                                                    exportOptions.VectorRasterizationOptions.SmoothingMode = Aspose.Imaging.SmoothingMode.None;
                                                                                                                                                                }

                                                                                                                                                                image.Save(outputFilePath, exportOptions);
                                                                                                                                                            }

Constructors

WebPOptions()

[JsonConstructor]
public WebPOptions()

Properties

AnimBackgroundColor

Gets or sets the color of the animation background.

[JsonProperty]
public uint AnimBackgroundColor { get; set; }

Property Value

uint

AnimLoopCount

Gets or sets the animation loop count.

[JsonProperty]
public ushort AnimLoopCount { get; set; }

Property Value

ushort

Lossless

Gets or sets a value indicating whether this Aspose.Imaging.ImageOptions.WebPOptions is lossless.

[JsonProperty]
public bool Lossless { get; set; }

Property Value

bool

Examples

This example shows how to create a WebP image from another raster image with different compression quality.```csharp [C#]

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

                                                                                                                  // Load a GIF animation
                                                                                                                  using (Aspose.Imaging.Image image = new Aspose.Imaging.Image.Load(dir + "test.gif"))
                                                                                                                  {
                                                                                                                      // for lossless compression, increasing the quality setting increases the compression quality and decreases the file size
                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_20.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 20 }); // file size: 42 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_50.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 50 }); // file size: 41 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_80.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 80 }); // file size: 40 KB


                                                                                                                      // for lossy compression, increasing the Quality value increases the image quality and increases the file size
                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_20.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 20 }); // file size: 24 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_50.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 50 }); // file size: 36 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_80.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 80 }); // file size: 51 KB
                                                                                                                  }

### <a id="Aspose_Imaging_ImageOptions_WebPOptions_Quality"></a> Quality

Gets or sets the quality.

```csharp
[JsonProperty]
public float Quality { get; set; }

Property Value

float

Examples

This example shows how to create a WebP image from another raster image with different compression quality.```csharp [C#]

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

                                                                                                                  // Load a GIF animation
                                                                                                                  using (Aspose.Imaging.Image image = new Aspose.Imaging.Image.Load(dir + "test.gif"))
                                                                                                                  {
                                                                                                                      // for lossless compression, increasing the quality setting increases the compression quality and decreases the file size
                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_20.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 20 }); // file size: 42 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_50.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 50 }); // file size: 41 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossless_80.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = true, Quality = 80 }); // file size: 40 KB


                                                                                                                      // for lossy compression, increasing the Quality value increases the image quality and increases the file size
                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_20.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 20 }); // file size: 24 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_50.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 50 }); // file size: 36 KB

                                                                                                                      image.Save(
                                                                                                                          dir + "output_lossy_80.webp",
                                                                                                                          new  Aspose.Imaging.ImageOptions.WebPOptions() { Lossless = false, Quality = 80 }); // file size: 51 KB
                                                                                                                  }