Class WebPImage

Class WebPImage

이름 공간 : Aspose.Imaging.FileFormats.Webp 모임: Aspose.Imaging.dll (25.4.0)

우리의 API를 사용하여 WebP 래스터 이미지를 조작하여 현대적인 기능을 사용합니다.손실없고 손실없는 압축, 최적의 이미지 품질을 줄이는 파일 크기.쉽게 확장 된 파일 형식, 애니메이션 및 알파 채널을 처리하지만 쉽게업데이트 차원, 회수 비례, 회수, 회전, 필터를 적용,이미지 매개 변수를 조정하고 다양한 이미지 형식으로 변환웹 이미지 최적화

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

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage RasterCachedMultipageImage WebPImage

Implements

IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata , IMultipageImageExt , IMultipageImage

상속 회원들

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

이 예제는 파일에서 WebP 이미지를 업로드하고 PNG로 저장하는 방법을 보여줍니다.

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

                                                                                      // Load a WebP image from a file.
                                                                                      using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(dir + "test.webp"))
                                                                                      {
                                                                                          // Save to PNG
                                                                                          // Note that only the active frame will be stored to PNG, since PNG is not a multi-page format.
                                                                                          webPImage.Save(dir + "test.output.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                      }

Constructors

웹 이미지(Stream)

Aspose.Imaging.FileFormats.Webp.WebPImage 클래스의 새로운 예를 즉시 시작합니다.제공되는 스트림 출처에서.이 건축기를 사용하여 무조건 WebP를 만들 수 있습니다.흐름에서 직접 이미지 개체, 효율적인 처리 및 조작을 가능하게귀하의 응용 프로그램 내에서 WebP 이미지 데이터를 제공합니다.

public WebPImage(Stream stream)

Parameters

stream Stream

흐름 WebP 이미지.

Examples

이 예제는 파일 스트림에서 WebP 이미지를 업로드하고 PNG로 저장하는 방법을 보여줍니다.

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

                                                                                             // Load a WebP image from a file stream.
                                                                                             using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "test.webp"))
                                                                                             using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(stream))
                                                                                             {
                                                                                                 // Save to PNG
                                                                                                 // Note that only the active frame will be stored to PNG, since PNG is not a multi-page format.
                                                                                                 webPImage.Save(dir + "test.output.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                             }

웹 이미지(흐름, LoadOptions)

Aspose.Imaging.FileFormats.Webp.WebPImage 클래스를 사용하여 새로운 예를 만드십시오.지정된 로드 옵션, WebP 이미지 데이터의 다양한 처리를 촉진합니다.이 디자이너를 통합하여 WebP 이미지 개체를 무시무시하게 시작하십시오.응용 프로그램 내에서 필요한 충전 매개 변수를 사용자 정의하는 동안 흐름.

public WebPImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

흐름 WebP 이미지.

loadOptions LoadOptions

로드 옵션

웹 이미지(스트리트)

Aspose.Imaging.FileFormats.Webp.WebPImage 클래스의 신선한 예를 즉시 시작하십시오.제공된 파일 출처에서.이 디자이너를 사용하여 무조건 WebP를 만들 수 있습니다.이미지 개체는 파일에서 직접, 충전 과정을 단순화하고귀하의 응용 프로그램 내에서 WebP 이미지 데이터를 조작합니다.

public WebPImage(string path)

Parameters

path string

WebP 이미지를 파일링하는 방법

Examples

이 예제는 파일에서 WebP 이미지를 업로드하고 PNG로 저장하는 방법을 보여줍니다.

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

                                                                                      // Load a WebP image from a file.
                                                                                      using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(dir + "test.webp"))
                                                                                      {
                                                                                          // Save to PNG
                                                                                          // Note that only the active frame will be stored to PNG, since PNG is not a multi-page format.
                                                                                          webPImage.Save(dir + "test.output.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                      }

웹 이미지(링크, LoadOptions)

파일을 사용하여 Aspose.Imaging.FileFormats.Webp.WebPImage 클래스의 새로운 예를 만들고지정된 로드 옵션, WebP 이미지 데이터의 유연한 처리를 촉진합니다.이 디자이너는 무조건 WebP 이미지 개체를 파일에서 시작할 수 있습니다.응용 프로그램의 요구 사항에 따라 충전 매개 변수를 사용자 정의합니다.

public WebPImage(string path, LoadOptions loadOptions)

Parameters

path string

WebP 이미지를 파일링하는 방법

loadOptions LoadOptions

로드 옵션

웹 이미지(RasterImage)

Aspose.Imaging.FileFormats.Webp.WebPImage 클래스의 새로운 예를 즉시 시작합니다.제공된 rasterImage 개체에서.이 건축기는 무선을 허용합니다라스터 이미지를 WebP 형식으로 변환하여 효율적인 처리 및귀하의 응용 프로그램 내에서 이미지 데이터의 조작.

public WebPImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

라스터 이미지 입니다.

Examples

이 예제는 다른 라스터 이미지에서 WebP 이미지를 만드는 방법을 보여줍니다.

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

                                                                                   // Load a PNG image of 100x100 px.
                                                                                   using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                   {
                                                                                       Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                       // Fill the entire image in red.
                                                                                       Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                       graphics.FillRectangle(brush, pngImage.Bounds);

                                                                                       // Create a WebP image based on the PNG image.
                                                                                       using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(pngImage))
                                                                                       {
                                                                                           // Save to a WebP file with default options
                                                                                           webPImage.Save(dir + "output.webp", new Aspose.Imaging.ImageOptions.WebPOptions());
                                                                                       }
                                                                                   }

웹 이미지(로드 옵션, LoadOptions)

Aspose.Imaging.FileFormats.Webp.WebPImage 클래스를 사용하여 새로운 예를 만드십시오.지정된 로드 옵션, 이미지 데이터의 유연한 처리 가능.디자이너는 무조건 WebP 이미지 개체를 라스터 이미지에서 시작할 수 있습니다.응용 프로그램의 요구 사항에 따라 충전 매개 변수를 사용자 정의합니다.

public WebPImage(RasterImage rasterImage, LoadOptions loadOptions)

Parameters

rasterImage RasterImage

라스터 이미지 입니다.

loadOptions LoadOptions

로드 옵션

웹 이미지(int, int, 웹포지션)

Aspose.Imaging.FileFormats.Webp.WebPImage 클래스의 새로운 예를 즉시 빈특정 폭 및 높이 차원의 이미지.이 건축기는흰색 WebP 이미지를 만드는 것, 다음 이미지를위한 기초를 제공당신의 응용 프로그램 내에서 조작 및 콘텐츠 생성.

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

Parameters

width int

넓은 이미지

height int

이미지 높이 입니다.

options WebPOptions

그 옵션들

Examples

이 예제는 스크래치에서 지정된 옵션으로 WebP 이미지를 만드는 방법을 보여줍니다.

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

                                                                                                 Aspose.Imaging.ImageOptions.WebPOptions createOptions = new Aspose.Imaging.ImageOptions.WebPOptions();
                                                                                                 createOptions.Lossless = true;
                                                                                                 createOptions.Quality = 100f;
                                                                                                 //createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.webp");

                                                                                                 // Create a WebP image of 100x100 px.
                                                                                                 using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(100, 100, createOptions))
                                                                                                 {
                                                                                                     Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(webPImage);

                                                                                                     // Fill the entire image in red.
                                                                                                     Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                     graphics.FillRectangle(brush, webPImage.Bounds);

                                                                                                     // Save to a WebP file
                                                                                                     webPImage.Save(dir + "output.webp");
                                                                                                 }

이 예제는 지정된 옵션으로 멀티 프레임 애니메이션 WebP 이미지를 만드는 방법을 보여줍니다.

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

                                                                                                         Aspose.Imaging.ImageOptions.WebPOptions createOptions = new Aspose.Imaging.ImageOptions.WebPOptions();
                                                                                                         createOptions.Lossless = true;
                                                                                                         createOptions.Quality = 100f;
                                                                                                         createOptions.AnimBackgroundColor = (uint)Aspose.Imaging.Color.Gray.ToArgb();

                                                                                                         // The default frame plus 36 + 36 additional frames.
                                                                                                         createOptions.AnimLoopCount = 36 + 36 + 1;

                                                                                                         // Create a WebP image of 100x100 px.
                                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(100, 100, createOptions))
                                                                                                         {
                                                                                                             // The first circle is red
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush1 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                             // The second circle is black
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush2 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Black);

                                                                                                             // Gradually inscrease the angle of the red arc shape.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);
                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(block);
                                                                                                                 graphics.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);

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

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Save to a WebP file
                                                                                                             webPImage.Save(dir + "output.webp");
                                                                                                         }

웹 이미지(int, int, WebPOptions, 로드옵션)

빈 이미지와 지정된 Aspose.Imaging.FileFormats.Webp.WebPImage 클래스의 새로운 예를 만드십시오.이 디자이너는 WebP 이미지를 시작할 수 있습니다.사용자 지정 충전 매개 변수, 이미지 생성에 유연성을 제공하고귀하의 응용 프로그램 내에서의 조작.

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

Parameters

width int

넓은 이미지

height int

이미지 높이 입니다.

options WebPOptions

그 옵션들

loadOptions LoadOptions

로드 옵션

Properties

FileFormat

이미지와 관련된 파일 형식 값에 액세스, 정보를 제공사진이 저장되는 형식에 대해.이 속성을 사용하여이미지의 파일 형식, 호환성 검사를 촉진하고귀하의 응용 프로그램 내에서 특정 형식 처리.

public override FileFormat FileFormat { get; }

부동산 가치

FileFormat

HasAlpha

이미지가 알파 채널을 포함하는지 여부를 확인하고,투명성 정보.이 재산을 사용하여 이미지를 결정하십시오.투명성을 포함하여 적절한 처리 및 처리를 가능하게 합니다.당신의 응용 프로그램 내에서 알파 관련 작업.

public override bool HasAlpha { get; }

부동산 가치

bool

Examples

다음 예제는 WEBP 이미지를 업로드하고 원료 데이터 형식 및 알파 채널에 대한 정보를 인쇄합니다.

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

                                                                                                                   string fileName = dir + "sample.webp";
                                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
                                                                                                                   {
                                                                                                                       Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                                                       // If the active TIFF frame has alpha channel, then the entire TIFF image is considered to have alpha channel.
                                                                                                                       System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, webpImage.RawDataFormat, webpImage.HasAlpha);

                                                                                                                       int i = 0;
                                                                                                                       foreach (Aspose.Imaging.FileFormats.Webp.IFrame frame in webpImage.Blocks)
                                                                                                                       {
                                                                                                                           Aspose.Imaging.FileFormats.Webp.WebPFrameBlock frameBlock = frame as Aspose.Imaging.FileFormats.Webp.WebPFrameBlock;
                                                                                                                           if (frameBlock != null)
                                                                                                                           {
                                                                                                                               System.Console.WriteLine("Frame={0}, FileFormat={1}, HasAlpha={2}", i++, frameBlock.RawDataFormat, frameBlock.HasAlpha);
                                                                                                                           }
                                                                                                                       }
                                                                                                                   }

                                                                                                                   // The output may look like this:
                                                                                                                   // ImageFile=c:\temp\sample.webp, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False
                                                                                                                   // Frame=0, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False

Options

지정된 재산과 관련된 옵션을 복구하거나 변경하여깔끔하게 조정된 행동 및 설정의 사용자 정의.이 재산을 사용하여무시무시하게 액세스하고 구성 가능한 매개 변수를 조작하여 다양성을 촉진합니다.제어 및 응용 프로그램의 기능 내에서 최적화.

[JsonProperty]
public WebPOptions Options { get; }

부동산 가치

WebPOptions

PageCount

지정된 문서 내의 전체 페이지 수를 복구하고,효율적인 탐색 및 멀티 페이지 콘텐츠 관리.이를 포함사용자 경험을 향상시키기위한 기능, 무제한 액세스를 허용포괄적 인 문서 구조.

public override int PageCount { get; }

부동산 가치

int

Pages

이미지 내의 WebP 블록에 액세스하여 자세한 검토 또는기본 블록 구조의 조작.이 속성을 사용하여 분석또는 WebP 이미지 데이터 내의 개별 블록을 변경하여 고급귀하의 응용 프로그램 내에서 이미지 처리 기술.

public override Image[] Pages { get; }

부동산 가치

Image [ ] [ [ ]

Methods

AddBlock(아이프라임)

이미지에 새로운 WebP 블록을 포함하여 콘텐츠를 풍요롭게하고고급 이미지 조작을 촉진합니다.이 방법을 역동적으로 통합WebP 이미지 데이터의 구조와 복잡성을 향상시킵니다.응용 프로그램, 이미지 순서의 정확한 제어 및 최적화를 가능하게합니다.

public void AddBlock(IFrame block)

Parameters

block IFrame

Webp 블록을 추가합니다.

Examples

이 예제는 지정된 옵션으로 멀티 프레임 애니메이션 WebP 이미지를 만드는 방법을 보여줍니다.

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

                                                                                                         Aspose.Imaging.ImageOptions.WebPOptions createOptions = new Aspose.Imaging.ImageOptions.WebPOptions();
                                                                                                         createOptions.Lossless = true;
                                                                                                         createOptions.Quality = 100f;
                                                                                                         createOptions.AnimBackgroundColor = (uint)Aspose.Imaging.Color.Gray.ToArgb();

                                                                                                         // The default frame plus 36 + 36 additional frames.
                                                                                                         createOptions.AnimLoopCount = 36 + 36 + 1;

                                                                                                         // Create a WebP image of 100x100 px.
                                                                                                         using (Aspose.Imaging.FileFormats.Webp.WebPImage webPImage = new Aspose.Imaging.FileFormats.Webp.WebPImage(100, 100, createOptions))
                                                                                                         {
                                                                                                             // The first circle is red
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush1 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);

                                                                                                             // The second circle is black
                                                                                                             Aspose.Imaging.Brushes.SolidBrush brush2 = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Black);

                                                                                                             // Gradually inscrease the angle of the red arc shape.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);
                                                                                                                 Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(block);
                                                                                                                 graphics.FillPie(brush1, block.Bounds, 0, angle);

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Gradually inscrease the angle of the black arc and wipe out the red arc.
                                                                                                             for (int angle = 10; angle <= 360; angle += 10)
                                                                                                             {
                                                                                                                 Aspose.Imaging.FileFormats.Webp.WebPFrameBlock block = new Aspose.Imaging.FileFormats.Webp.WebPFrameBlock(100, 100);

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

                                                                                                                 webPImage.AddBlock(block);
                                                                                                             }

                                                                                                             // Save to a WebP file
                                                                                                             webPImage.Save(dir + "output.webp");
                                                                                                         }

AddPage(RasterImage)

이미지에 새로운 페이지를 추가하고, 그 내용을 확장하고, 추가로 호스팅합니다.이 방법을 통합하여 역동적 인 페이지 관리를 촉진합니다.귀하의 응용 프로그램 내에서, 무제한 창조 및 멀티 페이지 확대를 허용문서 또는 이미지

public void AddPage(RasterImage page)

Parameters

page RasterImage

추가하는 페이지입니다.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(이트)

이미지에 대한 brightness’ 조정을 실행하여 전체 밝기 수준의 themodification을 허용합니다.이 방법을 이미지 처리 작업 흐름에 포함하여 시각성을 향상시키고 응용 프로그램 내에서 이미지의 시각적 품질을 향상시킵니다.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

빛의 가치

AdjustContrast(플로트)

Aspose.Imaging.Image의 대조를 향상시키고,빛과 어두운 영역의 차이점.이 방법을 이미지에 통합작업 흐름을 처리하여 시각적 명확성과 전체 이미지 품질을 향상시킵니다.당신의 신청

public override void AdjustContrast(float contrast)

Parameters

contrast float

대조 값 (내 범위 [-100; 100])

AdjustGamma(플로트)

이미지에 게마 수정을 적용하여 픽셀 강도를 조정하여원하는 밝기와 색상 균형.이 방법을 이미지에 포함작업 흐름을 처리하여 시각적 품질을 향상시키고 정확성을 향상시킵니다.귀하의 응용 프로그램 내에서 후속 분석 또는 표시 작업.

public override void AdjustGamma(float gamma)

Parameters

gamma float

빨간색, 녹색 및 파란색 채널에 대한 Gamma

AdjustGamma(해군, 해군, 해군)

빨간색에 대한 개별 요소를 사용하여 이미지에 게마 수정을 수행,녹색, 그리고 파란 채널, 색상 균형의 얇은 조정을 허용하고이 방법을 이미지 처리 파이프라인에 통합하여색상 렌더링을 정확하게 제어하고 내부의 시각적 충성도를 향상시킵니다.응용 프로그램

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

Parameters

gammaRed float

붉은 채널 요소를 위한 Gamma

gammaGreen float

녹색 채널 요소를 위한 Gamma

gammaBlue float

파란 채널 요소를 위한 Gamma

BinarizeBradley(이중, 이중)

Bradley의 adaptive thresholding 알고리즘을 사용하여 이미지에 바이너리화를 적용합니다.이 방법은 역동적으로 지역을 계산합니다.이미지의 이웃을 기반으로 한 한계, 변화에 적응성을 향상시키는조명 조건 및 나중에 처리하기 위해 강력한 분할을 보장귀하의 응용 프로그램 내의 작업.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

픽셀 사이의 밝기 차이와 픽셀의 s x s 창의 평균 차이이 픽셀 주위에 중점을 둡니다.

windowSize int

이 픽셀 주위에 중점을 둔 픽셀의 s x s 창의 크기

BinarizeFixed(바이트)

사전 정의 한계 값을 사용하여 이미지에 바이너리화를 수행, 변환그것은 바이너리 이미지로, 픽셀이 전면 또는 배경으로 분류되는 곳입니다.그들의 강도와 비교하여 경계에 따라.이 방법을 통합당신의 이미지 처리 작업 흐름은 분할 및 기능 추출을 촉진작업, 정확성과 나중 분석의 효율성을 향상시키는 내부응용 프로그램

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

픽셀의 해당 회색 값이 픽셀의 한계를 초과하는 경우, 픽셀의 값은 픽셀의 한계를 초과합니다.255은 그에게 맡겨질 것이며, 0은 다르게 맡겨질 것이다.

BinarizeOtsu()

Otsu의 경계 방법을 사용하여 이미지에 이중화를 수행, 자동으로이미지의 히스토그램을 바탕으로 최적의 한계 값을 결정합니다.이 방법은 효과적인 분할을 달성하기 위해 이미지 처리 작업 흐름에 들어갑니다.그리고 기능 추출, 이미지 분석의 정확성과 신뢰성을 향상시키는귀하의 응용 프로그램 내의 작업.

public override void BinarizeOtsu()

ClearBlocks()

이미지에서 모든 기존 WebP 블록을 제거하여 깨끗한 슬라이드를 촉진합니다.후속 변경 또는 추가.이 방법을 사용하여 효과적으로 재설정WebP 이미지 데이터 내의 블록 구조, 최적의 관리 및귀하의 응용 프로그램 내에서 이미지 콘텐츠의 조직.

public void ClearBlocks()

Crop(Rectangle)

특정 직경 지역을 사용하여 이미지를 심고 원치 않는 부분을 제거합니다.원하는 콘텐츠를 유지하는 동안.이 방법을 이미지에 통합처리 작업 흐름을 정확하게 추출하고 특정 관심 영역에 초점을 맞추기 위해이미지 내에서 다양한 응용 프로그램에 대한 명확성과 구성을 향상시킵니다.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

오른쪽 쪽 쪽

Crop(인트, 인트, 인트)

왼쪽, 오른쪽, 상단 및 하단 움직임을 적용하여 이미지를 효과적으로 재생합니다.이미지 내에서 관심 지역을 선택합니다.이 방법을 사용하여역동적으로 이미지의 원하는 부분을 추출하는 동안 그것의 구성 조정그리고 귀하의 응용 프로그램의 요구 사항에 따라 집중하십시오.

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

Parameters

leftShift int

왼쪽이 바뀐다.

rightShift int

올바른 변화

topShift int

꼭대기 변동

bottomShift int

밑바닥의 변화

Dither(Dithering 방법, int, IColorPalette)

현재 이미지를 실행하여 색 묶음을 줄이고 시각을 향상시킵니다.품질.이 방법을 이미지 처리 작업 흐름에 통합하여색상 사이의 부드러운 전환과 전체 모양을 향상시키는귀하의 응용 프로그램 내의 이미지입니다.

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

Parameters

ditheringMethod DitheringMethod

디트리밍 방법을 사용합니다.

bitsCount int

마지막 비트는 디트링을 위해 계산됩니다.

customPalette IColorPalette

Dithering을 위한 특정 팔레트.

Filter(오른쪽, FilterOptionsBase)

지정된 직경 내에서 콘텐츠를 필터링하여 지정된 이미지를 적용합니다.선택한 지역을 향상시키거나 변경하기 위해 필터를 처리합니다.이 방법을 통합목표 개선을 달성하기 위해 이미지 조작 작업 흐름 또는귀하의 응용 프로그램 내의 변형.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

오른쪽 쪽 쪽

options FilterOptionsBase

그 옵션들

Examples

다음 예제는 WEBP 이미지에 다양한 유형의 필터를 적용합니다.

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

                                                                                      // Apply a motion wiener filter with a length of 5, a smooth value of 4.0 and an angle of 90.0 degrees to the entire image.
                                                                                      webpImage.Filter(webpImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
                                                                                      webpImage.Save(dir + "sample.MotionWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.webp"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Webp.WebPImage webpImage = (Aspose.Imaging.FileFormats.Webp.WebPImage)image;

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

Grayscale()

그림을 그레이스케일 표현으로 변환하여 그것을단일 채널 이미지 각 픽셀은 강도 또는 빛을 나타냅니다.이 방법은 분석을 단순화하고 개선하기 위해 이미지 처리 파이프라인에 들어갑니다.Grayscale 기반 알고리즘과 호환성, 다양한 컴퓨터를 촉진당신의 응용 프로그램 내에서 비전 및 이미지 분석 작업.

public override void Grayscale()

InsertBlock(이브라임, IFRAM)

이미지 내에서 지정된 인덱스에 새로운 WebP 블록을 삽입하여 정확성을 제공합니다.블록 순서를 통제합니다.이 방법을 통합하여 무조건 통합합니다.이미지 데이터 구조에 추가 WebP 블록, 고급 이미지를 촉진귀하의 응용 프로그램 내에서 처리 및 최적화.

public void InsertBlock(int index, IFrame block)

Parameters

index int

block’이 삽입되는 0 기반 요소입니다.

block IFrame

Webp 블록을 추가합니다.

ReleaseManagedResources()

관리 된 자원을 풀어주십시오. 관리되지 않은 자원이 여기에 풀어주지 않도록하십시오.이미 풀려났다.

protected override void ReleaseManagedResources()

RemoveBlock(아이프라임)

이미지에서 지정된 WebP 블록을 제거하여 효율적인 관리를 촉진합니다.이미지 데이터 구조.이 방법을 사용하여 이미지 처리를 단순화합니다.응용 프로그램 내에서 불필요한 블록이나 구성 요소를 제거함으로써 작업 흐름.

public void RemoveBlock(IFrame block)

Parameters

block IFrame

블록을 제거해야 합니다.

Remarks

참고: 다른 WebPImage에 추가하지 않으려면 block’를 배치하는 것을 잊지 마십시오.

Resize(인트, 인트, ResizeType)

이미지를 재구성하고 측면 비율을 유지하면서 차원을 조정합니다.이 방법을 이미지 처리 작업 흐름에 통합하여 역동적으로 확장하십시오.이미지는 응용 프로그램 내에서 다양한 표시 또는 저장 요구 사항에 맞게 합니다.

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

Parameters

newWidth int

새로운 광도 입니다.

newHeight int

새로운 높이 입니다.

resizeType ResizeType

리세스 타입이죠.

Examples

이 예제는 WEBP 이미지를 업로드하고 다양한 리시링 방법을 사용하여 재시작합니다.

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

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

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

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

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

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

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

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

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

Resize(이트, 이트, ImageResizeSettings)

지정된 설정에 따라 이미지를 재구성하여 정확한 제어를 가능하게 합니다.차원, 측면 비율, 그리고 확장 행동.이 방법을 당신의이미지 처리 작업 흐름을 달성하기 위해 사용자 지정 재활용 작업을귀하의 신청서의 특정 요구 사항

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

Parameters

newWidth int

새로운 광도 입니다.

newHeight int

새로운 높이 입니다.

settings ImageResizeSettings

재구성 설정에 대하여

ResizeHeightProportionally(인트, ResizeType)

이미지의 높이를 비례적으로 조정하고 동시에 측면 비율을 유지합니다.이 방법을 이미지 처리 작업 흐름에 통합동일한 비율로 역동적으로 이미지를 재시작하여 최적의 표시 또는귀하의 응용 프로그램 내에 저장합니다.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

새로운 높이 입니다.

resizeType ResizeType

리시스의 종류입니다.

ResizeWidthProportionally(인트, ResizeType)

비율적으로 이미지의 폭을 조정하면서 측면 비율을 유지합니다.이 방법을 이미지 처리 작업 흐름에 통합하여 역동적으로 재구성합니다.일관된 비율을 가진 이미지, 최적의 표시 또는 내부 저장당신의 신청

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

새로운 광도 입니다.

resizeType ResizeType

리시스의 종류입니다.

Rotate(플로트, 볼, 색상)

그것의 중심 주위에 그림을 지정된 각도로 회전하고, 비례적으로그것을 재구성하고 지정된 배경 색상 매개 변수를 적용합니다.이를 포함당신의 이미지 처리 작업 흐름에 방법 정확한 변환을 달성하기 위해사용자 지정 가능한 배경 색상, 최적의 시각적 프레젠테이션 내에서 보장응용 프로그램

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

Parameters

angle float

긍정적 값은 시계로 회전합니다.

resizeProportionally bool

‘진실’으로 설정하면 이미지 크기가 변경되며, 다른 경우에는 측정이 터치되지 않고 internal 이미지 콘텐츠만 회전됩니다.

backgroundColor Color

배경의 색깔.

RotateFlip(RotateFlipType)

회전, 플리핑 또는 두 가지 작업을 활성 프레임에만 적용합니다.이 방법을 이미지 처리 작업 흐름에 통합하여개별 프레임의 정확한 조작을 제공하고, 유연성을 향상시키고,당신의 응용 프로그램 내에서 프레임 변환을 제어합니다.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

로테이트 플립 유형

SaveData(Stream)

데이터를 저장합니다.

protected override void SaveData(Stream stream)

Parameters

stream Stream

데이터를 저장하기위한 스트림.

UpdateDimensions(이트, 이트)

이미지 차원을 업데이트합니다.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

새로운 이미지 폭.

newHeight int

새로운 이미지 높이.

 한국어