Class DjvuImage

Class DjvuImage

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

DjVu 문서 클래스는 그래픽 파일 형식을 지원하고 무선을 촉진합니다.스캔 된 문서와 책의 관리, 텍스트, 그림, 이미지를 통합,그리고 사진은 단일 형식으로 제공됩니다. 멀티 페이지 작업을 지원하면,효율적으로 독특한 문서 식별자에 액세스, 페이지를 계산, 활성 페이지를 설정,그리고 특정 문서 페이지를 복구합니다. 재시작, 회전을위한 기능으로,디트링, 굴곡, 그레이스칼 변환, 가마 수정, 조정,그리고 응용 프로그램을 필터링,이 클래스는 정확한 조작 및 개선을 가능하게DjVu 이미지는 다양한 응용 프로그램 요구 사항을 쉽고 정확하게 충족시킵니다.

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

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage RasterCachedMultipageImage DjvuImage

Implements

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

상속 회원들

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

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

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

                                                                          // Load a DJVU image from a file stream.
                                                                          using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                          {
                                                                              using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
                                                                              {
                                                                                  // Save each page as an individual PNG image.
                                                                                  foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                  {
                                                                                      // Generate a file name based on the page number.
                                                                                      string fileName = string.Format("sample.{0}.png", djvuPage.PageNumber);
                                                                                      djvuPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }
                                                                              }
                                                                          }

Constructors

DjvuImage(Stream)

DjVu 이미지와 함께 작업을 시작하여 새로운 사례를 시작합니다.Aspose.Imaging.FileFormats.Djvu.DjvuImage 클래스는 스트림 매개 변수를 사용합니다.개발자들은 DjVu 이미지 처리의 무시무시한 통합을 원합니다.그들의 프로젝트

public DjvuImage(Stream stream)

Parameters

stream Stream

그 흐름을

Examples

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

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

                                                                          // Load a DJVU image from a file stream.
                                                                          using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                          {
                                                                              using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
                                                                              {
                                                                                  // Save each page as an individual PNG image.
                                                                                  foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                  {
                                                                                      // Generate a file name based on the page number.
                                                                                      string fileName = string.Format("sample.{0}.png", djvuPage.PageNumber);
                                                                                      djvuPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }
                                                                              }
                                                                          }

Exceptions

DjvuImageException

흐름이 텅 비어있다

DjvuImage(흐름, LoadOptions)

이 디자이너와 함께 DjVu 이미지와 함께 작업을 시작하십시오.새로운 Aspose.Imaging.FileFormats.Djvu.DjvuImage 클래스 사례를 시작하여 스트림과LoadOptions 매개 변수. 정확한 제어를 원하는 개발자를위한 완벽DjVu 이미지 충전 옵션은 간단함과 효율성을 유지합니다.

public DjvuImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

흐름을 충전할 수 있습니다.

loadOptions LoadOptions

로드 옵션

Examples

이 예제는 지정된 메모리 한도 내에 머무르기 위해 파일 스트림에서 DJVU 이미지를 업로드하는 방법을 보여줍니다.

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

                                                                                                                    // Load a DJVU image from a file stream.
                                                                                                                    using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                                                                    {
                                                                                                                        // The max allowed size for all internal buffers is 1MB.
                                                                                                                        Aspose.Imaging.LoadOptions loadOptions = new Aspose.Imaging.LoadOptions();
                                                                                                                        loadOptions.BufferSizeHint = 1 * 1024 * 1024;

                                                                                                                        using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream, loadOptions))
                                                                                                                        {
                                                                                                                            // Save each page as an individual PNG image.
                                                                                                                            foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                                                            {
                                                                                                                                // Generate a file name based on the page number.
                                                                                                                                string fileName = string.Format("sample.{0}.png", djvuPage.PageNumber);
                                                                                                                                djvuPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                            }
                                                                                                                        }
                                                                                                                    }

Exceptions

DjvuImageException

흐름이 텅 비어있다

Properties

ActivePage

현재 활성화된 문서에 액세스하거나 설정함으로써 DjVu 문서를 탐색하십시오.이 속성을 사용하는 페이지.특정 페이지에 초점을 맞추기 위해 페이지 사이를 끊임없이 전환콘텐츠 및 문서 보기 경험을 향상시킵니다.

public DjvuPage ActivePage { get; set; }

부동산 가치

DjvuPage

Examples

이 예제는 파일 스트림에서 DJVU 이미지를 업로드하고 페이지에 대한 정보를 인쇄하는 방법을 보여줍니다.

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

                                                                                                                // Load a DJVU image from a file stream.
                                                                                                                using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                                                                {
                                                                                                                    using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
                                                                                                                    {
                                                                                                                        System.Console.WriteLine("The total number of pages: {0}", djvuImage.Pages.Length);
                                                                                                                        System.Console.WriteLine("The active page number:    {0}", djvuImage.ActivePage.PageNumber);
                                                                                                                        System.Console.WriteLine("The first page number:     {0}", djvuImage.FirstPage.PageNumber);
                                                                                                                        System.Console.WriteLine("The last page number:      {0}", djvuImage.LastPage.PageNumber);

                                                                                                                        foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                                                        {
                                                                                                                            System.Console.WriteLine("--------------------------------------------------");
                                                                                                                            System.Console.WriteLine("Page number:     {0}", djvuPage.PageNumber);
                                                                                                                            System.Console.WriteLine("Page size:       {0}", djvuPage.Size);
                                                                                                                            System.Console.WriteLine("Page raw format: {0}", djvuPage.RawDataFormat);
                                                                                                                        }
                                                                                                                    }
                                                                                                                }

                                                                                                                //The output may look like this:
                                                                                                                //The total number of pages: 2
                                                                                                                //The active page number:    1
                                                                                                                //The first page number:     1
                                                                                                                //The last page number:      2
                                                                                                                //--------------------------------------------------
                                                                                                                //Page number:     1
                                                                                                                //Page size:       { Width = 2481, Height = 3508}
                                                                                                                //Page raw format: RgbIndexed1Bpp, used channels: 1
                                                                                                                //--------------------------------------------------
                                                                                                                //Page number:     2
                                                                                                                //Page size:       { Width = 2481, Height = 3508}
                                                                                                                //Page raw format: RgbIndexed1Bpp, used channels: 1

Exceptions

DjvuImageException

선택된 활성 페이지가 없습니다.

DjvuPages

이 문서를 사용하여 DjVu 문서 내에 포함된 모든 페이지를 빠르게 복구하십시오.문서 처리 작업 흐름을 단순화하여 쉽게 액세스하고DjVu 파일 내에서 개별 페이지를 관리합니다. 효율성을 향상시키고귀하의 작업을 편리한 페이지 복구로 단순화하십시오.

public DjvuPage[] DjvuPages { get; }

부동산 가치

DjvuPage [ ] [ [ ]

FileFormat

DjVu 이미지 파일과 관련된 파일 형식 정보를 얻으십시오.당신의 작업 흐름에 무시무시한 통합을 위해 파일의 형식을 결정합니다.

public override FileFormat FileFormat { get; }

부동산 가치

FileFormat

FirstPage

이 부동산으로 DjVu 문서의 첫 페이지에 액세스하십시오.문서를 효율적으로 시청하거나 처리하기 시작하는 초기 페이지입니다.

public DjvuPage FirstPage { get; }

부동산 가치

DjvuPage

Examples

이 예제는 파일 스트림에서 DJVU 이미지를 업로드하고 페이지에 대한 정보를 인쇄하는 방법을 보여줍니다.

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

                                                                                                                // Load a DJVU image from a file stream.
                                                                                                                using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                                                                {
                                                                                                                    using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
                                                                                                                    {
                                                                                                                        System.Console.WriteLine("The total number of pages: {0}", djvuImage.Pages.Length);
                                                                                                                        System.Console.WriteLine("The active page number:    {0}", djvuImage.ActivePage.PageNumber);
                                                                                                                        System.Console.WriteLine("The first page number:     {0}", djvuImage.FirstPage.PageNumber);
                                                                                                                        System.Console.WriteLine("The last page number:      {0}", djvuImage.LastPage.PageNumber);

                                                                                                                        foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                                                        {
                                                                                                                            System.Console.WriteLine("--------------------------------------------------");
                                                                                                                            System.Console.WriteLine("Page number:     {0}", djvuPage.PageNumber);
                                                                                                                            System.Console.WriteLine("Page size:       {0}", djvuPage.Size);
                                                                                                                            System.Console.WriteLine("Page raw format: {0}", djvuPage.RawDataFormat);
                                                                                                                        }
                                                                                                                    }
                                                                                                                }

                                                                                                                //The output may look like this:
                                                                                                                //The total number of pages: 2
                                                                                                                //The active page number:    1
                                                                                                                //The first page number:     1
                                                                                                                //The last page number:      2
                                                                                                                //--------------------------------------------------
                                                                                                                //Page number:     1
                                                                                                                //Page size:       { Width = 2481, Height = 3508}
                                                                                                                //Page raw format: RgbIndexed1Bpp, used channels: 1
                                                                                                                //--------------------------------------------------
                                                                                                                //Page number:     2
                                                                                                                //Page size:       { Width = 2481, Height = 3508}
                                                                                                                //Page raw format: RgbIndexed1Bpp, used channels: 1

Exceptions

DjvuImageException

첫 페이지는 찾을 수 없습니다.

HasAlpha

DjVu 이미지 파일이 알파 채널을 포함하는지 신속하게 확인하십시오.투명성 정보의 존재를 확인함으로써 작업 흐름을 단순화당신의 이미지에서.

public override bool HasAlpha { get; }

부동산 가치

bool

Identifier

문서에 대한 독특한 식별자를 얻습니다.

public int Identifier { get; }

부동산 가치

int

LastPage

이 재산을 사용하여 DjVu 문서의 마지막 페이지를 복구합니다.쉬운 시청 또는 처리 목적으로 최종 페이지입니다.

public DjvuPage LastPage { get; }

부동산 가치

DjvuPage

Examples

이 예제는 파일 스트림에서 DJVU 이미지를 업로드하고 페이지에 대한 정보를 인쇄하는 방법을 보여줍니다.

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

                                                                                                                // Load a DJVU image from a file stream.
                                                                                                                using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                                                                {
                                                                                                                    using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
                                                                                                                    {
                                                                                                                        System.Console.WriteLine("The total number of pages: {0}", djvuImage.Pages.Length);
                                                                                                                        System.Console.WriteLine("The active page number:    {0}", djvuImage.ActivePage.PageNumber);
                                                                                                                        System.Console.WriteLine("The first page number:     {0}", djvuImage.FirstPage.PageNumber);
                                                                                                                        System.Console.WriteLine("The last page number:      {0}", djvuImage.LastPage.PageNumber);

                                                                                                                        foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                                                        {
                                                                                                                            System.Console.WriteLine("--------------------------------------------------");
                                                                                                                            System.Console.WriteLine("Page number:     {0}", djvuPage.PageNumber);
                                                                                                                            System.Console.WriteLine("Page size:       {0}", djvuPage.Size);
                                                                                                                            System.Console.WriteLine("Page raw format: {0}", djvuPage.RawDataFormat);
                                                                                                                        }
                                                                                                                    }
                                                                                                                }

                                                                                                                //The output may look like this:
                                                                                                                //The total number of pages: 2
                                                                                                                //The active page number:    1
                                                                                                                //The first page number:     1
                                                                                                                //The last page number:      2
                                                                                                                //--------------------------------------------------
                                                                                                                //Page number:     1
                                                                                                                //Page size:       { Width = 2481, Height = 3508}
                                                                                                                //Page raw format: RgbIndexed1Bpp, used channels: 1
                                                                                                                //--------------------------------------------------
                                                                                                                //Page number:     2
                                                                                                                //Page size:       { Width = 2481, Height = 3508}
                                                                                                                //Page raw format: RgbIndexed1Bpp, used channels: 1

Exceptions

DjvuImageException

마지막 페이지는 찾을 수 없습니다.

NextPage

이와 함께 다음 페이지에 액세스하여 DjVu 문서를 탐색하십시오.편리한 재산. 빠르게 문서 보기 또는처리 작업

public DjvuPage NextPage { get; }

부동산 가치

DjvuPage

Exceptions

DjvuImageException

다음 페이지는 찾을 수 없습니다.

PageCount

이 숙박 시설을 사용하여 DjVu 이미지 컬렉션의 전체 페이지 수를 복구합니다.DjVu 형식으로 저장된 문서 또는 책의 범위를 신속하게 평가하는 데 이상적입니다.정확한 페이지 계산 정보로 작업 흐름 효율성을 향상시킵니다.

public override int PageCount { get; }

부동산 가치

int

Pages

이 속성으로 DjVu 이미지 컬렉션의 개별 페이지에 액세스하십시오.DjVu 형식으로 저장된 문서 또는 책의 간단한 탐색 및 조작각 페이지에 직접 액세스함으로써 작업 흐름 효율성을 쉽게 향상시킵니다.페이지 리트리얼

public override Image[] Pages { get; }

부동산 가치

Image [ ] [ [ ]

Examples

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

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

                                                                          // Load a DJVU image from a file stream.
                                                                          using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
                                                                          {
                                                                              using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
                                                                              {
                                                                                  // Save each page as an individual PNG image.
                                                                                  foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
                                                                                  {
                                                                                      // Generate a file name based on the page number.
                                                                                      string fileName = string.Format("sample.{0}.png", djvuPage.PageNumber);
                                                                                      djvuPage.Save(dir + fileName, new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }
                                                                              }
                                                                          }

PreviousPage

DjVu 문서 보기 또는 처리 작업에 빠르게 뒤로 이동이 편리한 속성으로 이전 페이지에 액세스합니다.효율적으로 탐색귀하의 문서를 통해 쉽게

public DjvuPage PreviousPage { get; }

부동산 가치

DjvuPage

Exceptions

DjvuImageException

이전 페이지는 찾을 수 없습니다.

Methods

AdjustBrightness(이트)

특정 매개 변수를 사용하여 이미지의 <코드 클래스=“paramref”> 밝기를 조정하여 최적의 시각적 명확성을 위해 빛의 수준을 제어합니다.이 방법 강화기는 이미지의 전체 밝기를 감소시키고, 얇은 조정이 원하는 조명 효과를 달성 할 수 있습니다. 밝기를 조정함으로써 사용자는 이미지 시각성을 최적화하고 더 나은 시청 경험을 위해 세부 사항 재생을 향상시킬 수 있습니다.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

빛의 가치

Examples

다음 예제는 DJVU 이미지의 밝기 수정을 수행합니다.

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

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                {
                                                                                    Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

AdjustContrast(플로트)

Aspose.Imaging.Image 대조를 향상시켜 시각적 명확성을 향상시키고이 방법으로 세부 사항을 강조하여 밝기 차이를 조정합니다.빛과 어두운 영역. 얇은 톤의 대조 수준에 의해, 사용자는 더 활기차고영향력있는 이미지, 전체 이미지 품질을 향상시키고 세부 사항의 가시성을 최대화합니다.이 조정은 색상과 구조의 미묘한 색조를 제거하는 데 도움이되며, 결과적으로더 역동적이고 시각적으로 매력적인 이미지.

public override void AdjustContrast(float contrast)

Parameters

contrast float

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

Examples

다음 예제는 DJVU 이미지의 대조 수정을 수행합니다.

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

                                                                              using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                              {
                                                                                  Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

AdjustGamma(플로트)

Gamma 수정, 특히 빨간색, 녹색 및 파란 채널에 대 한, 조정 포함각 색상 구성 요소의 밝기 개별적으로.다양한 gamma를 적용함으로써RGB 채널에 대한 요소, 당신은 전체 밝기와 대조를 잘 톤 할 수 있습니다이 기술은 정확한 색상 표현을 보장하고 색상을 향상시킵니다.다양한 디스플레이 장치에서 이미지의 시각적 품질.

public override void AdjustGamma(float gamma)

Parameters

gamma float

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

Examples

다음 예제는 DJVU 이미지의 가마 수정을 수행합니다.

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

                                                                           using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                           {
                                                                               Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

AdjustGamma(해군, 해군, 해군)

Gamma 수정은 빨간색, 녹색에 대한 사용자 지정 가능한 매개 변수를 가진 이미지에 적용됩니다.그리고 파란 채널, 색상 균형과 밝기의 정확한 조정을 허용합니다.방법은 얇은 색상 표현을 통해 이미지 품질을 향상시키고 최적의 색상을 보장합니다.다양한 디스플레이 장치를 통해 렌더링.개인에 대한 가마 값을 조정채널은 색상 균형과 시각적 매력을 향상시킵니다.

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

Parameters

gammaRed float

붉은 채널 요소를 위한 Gamma

gammaGreen float

녹색 채널 요소를 위한 Gamma

gammaBlue float

파란 채널 요소를 위한 Gamma

Examples

다음 예제는 색상 구성 요소에 대한 다른 요소를 적용하는 DJVU 이미지의 가마 수정을 수행합니다.

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

                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                {
                                                                                                                                    Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

BinarizeBradley(이중, 이중)

브래들리의 적응형 경계 알고리즘을 사용하여 이중화경계선은 각 픽셀에 대한 지역 경계선을 계산하는 방법입니다.그것은 이미지에 걸쳐 조명의 변형에 적응, 그것을 만드는불평등한 조명 조건을 가진 이미지에 적합합니다.포괄적 인 이미지, 그것은 효율적으로 큰 이웃을 처리, 그것을 적용하기 위해실시간 응용 프로그램.이 기술은 일반적으로 문서 처리, OCR에서 사용됩니다.(Optical Character Recognition) 및 이미지 분할 작업 정확한 경우바이너리화는 나중에 분석하는 데 필수적입니다.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

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

windowSize int

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

Examples

다음 예제는 Bradley의 적응형 경계 알고리즘과 지정된 창 크기로 DJVU 이미지를 이중화합니다.

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

                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                                                {
                                                                                                                                                                                                    Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

                                                                                                                                                                                                    // Binarize the image with a brightness difference of 5. The brightness is a difference between a pixel and the average of an 10 x 10 window of pixels centered around this pixel.
                                                                                                                                                                                                    djvuImage.BinarizeBradley(5, 10);
                                                                                                                                                                                                    djvuImage.Save(dir + "sample.BinarizeBradley5_10x10.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                                                }

BinarizeFixed(바이트)

미리 정의 한계를 가진 바이너리화는 복잡한 이미지를 바이너리로 단순화합니다.픽셀은 블랙 또는 흰색으로 분류되며, 그 픽셀에 따라 분류됩니다.강도와 비교하여 특정 한도 값.이 기술은 일반적으로 사용됩니다이미지를 처리하여 명확성을 향상시키고, 분석을 단순화하고, 더 많은 이미지를 준비합니다.OCR (Optical Character Recognition)와 같은 처리 단계한계, 당신은 빨리 그레이 스케일 이미지를 바이너리 형태로 변환, 그들을 만들 수 있습니다의미있는 정보를 해석하고 추출하는 것이 더 쉽습니다.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

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

Examples

다음 예제는 미리 정의된 경계선을 가진 DJVU 이미지를 바이너리화합니다. 바이너리화 된 이미지는 단지 2 가지 색상 - 검정색과 흰색을 포함합니다.

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

                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)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()

Binarization using Otsu thresholding는 자동으로 계산하는 기술입니다.최적의 경계 값은 이미지의 histogram을 기반으로합니다.그것은 이미지를 분리합니다.전면 및 배경을 최소화하여 인트라 클래스 변형.Otsu의 방법은광범위하게 이미지를 바이너리 형태로 분류하는 데 사용되며, 특히 배포픽셀 강도는 bimodal 또는 multimodal입니다.이 접근 방식은 작업에 유익합니다.예를 들어 개체 탐지, 이미지 분할 및 기능 추출, 정확한 경우앞면과 배경 사이의 정렬은 중요합니다.

public override void BinarizeOtsu()

Examples

다음 예제는 Otsu 경계를 가진 DJVU 이미지를 바이너리화합니다. 바이너리화 된 이미지는 단지 2 가지 색상 - 검정색과 흰색을 포함합니다.

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

                                                                                                                                         using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                         {
                                                                                                                                             Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

CacheData()

성능을 최적화하고 반복 데이터의 필요성을 줄이기 위해 데이터를 개인적으로 숨기십시오.외부 출처에서 회수.이 접근 방식은 또한 자원을 보존하는 데 도움이됩니다.특히 데이터 접근이 빈번하거나 자원이 제한된 시나리오에서.

public override void CacheData()

Examples

다음 예제는 DJVU 이미지의 모든 페이지를 암호화하는 방법을 보여줍니다.

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

                                                                              // Load an image from a DJVU file.
                                                                              using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                              {
                                                                                  // This call caches all the pages so that no additional data loading will be performed from the underlying data stream.
                                                                                  image.CacheData();

                                                                                  // Or you can cache the pages individually.
                                                                                  foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage page in image.Pages)
                                                                                  {
                                                                                      page.CacheData();
                                                                                  }
                                                                              }

Crop(Rectangle)

“식물"은 특정 세부 사항에 초점을 맞추거나 원치 않는 요소를 제거하기 위해 이미지를 보냅니다.그것의 구성과 시각적 영향을 향상시킵니다.당신이 사진을 사회적으로 조정하고 있는지 여부미디어, 웹 사이트 배너 만들기, 또는 인쇄 자료를 설계,이 도구는 당신을 도와줍니다당신의 이미지를 정확성과 명확성으로 정리하십시오.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

오른쪽 쪽 쪽

Examples

다음 예제는 DJVU 이미지를 재배합니다. 재배 영역은 Aspose.Imaging.Rectangle을 통해 지정됩니다.

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

                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                    {
                                                                                                                        Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

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

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)

“Dither” 함수는 이미지에 디트링 효과를 적용하여 시각을 향상시킵니다.품질은 묶음을 줄이고 색상 전환을 향상시킵니다.디지털 예술, 사진 또는 그래픽 디자인 프로젝트에 관해서는, 이 기능은당신의 이미지에 전문적인 접촉, 그들이 더 부드럽고 더 정화 된 보이게합니다.

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

Parameters

ditheringMethod DitheringMethod

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

bitsCount int

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

customPalette IColorPalette

Dithering을 위한 특정 팔레트.

Examples

다음 예제는 DJVU 이미지를 업로드하고 다른 팔레트 깊이를 사용하여 경계 및 흐름 디트링을 수행합니다.

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

                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                             {
                                                                                                                                 Aspose.Imaging.FileFormats.Djvu.DjvuImage dicomImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)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.
                                                                                                                                 dicomImage.Dither(Aspose.Imaging.DitheringMethod.ThresholdDithering, 4, null);

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

                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                             {
                                                                                                                                 Aspose.Imaging.FileFormats.Djvu.DjvuImage dicomImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)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.
                                                                                                                                 dicomImage.Dither(Aspose.Imaging.DitheringMethod.FloydSteinbergDithering, 1, null);

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

Filter(오른쪽, FilterOptionsBase)

그림 내에서 지정된 직경 영역에 필터를 적용하여 그림을 향상시키거나 변경합니다.특정 지역을 타겟팅함으로써 이 방법은 정확한 조정을 허용합니다.예를 들어, 원하는 시각을 달성하기 위해 예술적 효과를 뿌리거나, 절단하거나 적용하는 것과 같습니다.결과 : 선택한 영역에 있는 얇은 튜닝 필터는 사용자가 이미지를 사용자 정의할 수 있게 합니다.아름다움, 명확성을 향상시키고, 그들의 취향에 맞는 예술 효과를 만듭니다.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

오른쪽 쪽 쪽

options FilterOptionsBase

그 옵션들

Examples

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

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

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

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

Grayscale()

Grayscale 변환은 이미지를 검정색과 흰색으로 변환합니다.각 픽셀의 강도는 검정색에서 흰색까지의 단일 값으로 나타납니다.이 과정은 색상 정보를 제거하여 단색 이미지로 이어집니다.Grayscale이미지는 색상이 불필요하거나 간단함이 있는 응용 프로그램에서 일반적으로 사용됩니다.예를 들어 문서 검사, 인쇄 및 특정 유형의 이미지 분석과 같은 선호합니다.

public override void Grayscale()

Examples

다음 예제는 다채로운 DJVU 이미지를 그레이 스케일 표현으로 변환합니다.그레이 스케일 이미지는 독점적으로 회색의 그림자로 구성되어 있으며 강도 정보만 제공됩니다.

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

                                                                                                                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                                                   {
                                                                                                                                                                                                       Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

LoadDocument(Stream)

이 방법으로 DjVu 문서를 업로드합니다.이 방법으로 프로세스를 빠르게 스트리밍합니다.귀하의 DjVu 파일을 귀하의 응용 프로그램에 액세스하고 가져오십시오.

public static DjvuImage LoadDocument(Stream stream)

Parameters

stream Stream

그 흐름을

Returns

DjvuImage

업로드된 DJVU 문서

LoadDocument(흐름, LoadOptions)

흐름과 로드와 함께이 방법을 사용하여 DjVu 문서를 가져오십시오.프로세스를 빠르게 액세스하고 DjVu 파일을 수입함으로써 스트리밍귀하의 응용 프로그램에, 유연성과 사용자 정의 옵션을 제공당신의 필요

public static DjvuImage LoadDocument(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

그 흐름을

loadOptions LoadOptions

로드 옵션

Returns

DjvuImage

업로드된 DJVU 문서

ReleaseManagedResources()

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

protected override void ReleaseManagedResources()

Resize(인트, 인트, ResizeType)

이미지를 사용하여 재구성합니다. Resize 방법, 간단하고 효과적인 방법을 제공귀하의 요구 사항에 따라 이미지의 크기를 조정할 수 있습니다.이다양한 기능은 당신이 원하는 크기로 이미지를 쉽게 확장 할 수있게합니다.다양한 플랫폼 및 응용 프로그램에서 사용 가능성을 향상시킵니다.

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

Parameters

newWidth int

새로운 광도 입니다.

newHeight int

새로운 높이 입니다.

resizeType ResizeType

리세스 타입이죠.

Examples

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

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

                                                                                         using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                         {
                                                                                             // 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.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                         {
                                                                                             // 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.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                         {
                                                                                             // 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.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                         {
                                                                                             // 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

재구성 설정에 대하여

Examples

이 예제는 DJVU 이미지를 업로드하고 다양한 재시지 설정을 사용하여 재시지합니다.

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.djvu"))
                                                                                          {
                                                                                              Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)image;

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

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

ResizeHeightProportionally(인트, ResizeType)

The ResizeHeightProportionally 방법은 당신이 당신의 높이를 조정할 수 있습니다이미지를 유지하면서 측면 비율을 유지합니다.이것은 이미지를 유지하는 것을 보장합니다.그것의 비율, 왜곡을 방지하고 그것의 시각적 무결성을 보존합니다.웹 페이지, 모바일 애플리케이션 또는 인쇄 미디어에 대한 이미지를 최적화하고 있는지 여부, 이이 방법은 이미지가 다양한 플랫폼과 장치에서 가장 잘 보이는 것을 보장합니다.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

새로운 높이 입니다.

resizeType ResizeType

리시스의 종류입니다.

Examples

이 예제는 DJVU 이미지를 업로드하고 다양한 리시팅 방법을 사용하여 비례적으로 재시작합니다.만 높이가 지정되고 폭이 자동으로 계산됩니다.

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);

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

ResizeWidthProportionally(인트, ResizeType)

The ResizeWidthProportionally 이 방법은 편리한 해결책을 제공합니다.당신의 이미지의 폭을 유지하는 동안 그것의 측면 비율.광도, 당신은 당신의 이미지가 시각적으로 매력적으로 남아 있는지 확인할 수 있습니다.다양한 장치와 스크린 크기에 일관되며 다양성을 향상시킵니다.다양한 맥락에서 사용 가능성.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

새로운 광도 입니다.

resizeType ResizeType

리시스의 종류입니다.

Examples

이 예제는 DJVU 이미지를 업로드하고 다양한 리시팅 방법을 사용하여 비례적으로 재시작합니다.

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.BilinearResample);

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

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.BilinearResample);

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

Rotate(플로트, 볼, 색상)

그것의 중심 주위에 이미지를 회전하는 방법을 사용하여RasterCachedMultipageImage 클래스.이 편리한 기능은 쉽게 사용할 수 있습니다.이미지의 방향을 조정하고 중앙 위치를 유지하면서,당신의 이미지 조작 능력을 향상시킵니다.

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

Parameters

angle float

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

resizeProportionally bool

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

backgroundColor Color

배경의 색깔.

RotateFlip(RotateFlipType)

The RotateFlip 이 방법은 이미지에 대한 다양한 조작 옵션을 제공하며,당신은 회전, flip, 또는 활성 프레임에 두 작업을 독립적으로 수행 할 수 있습니다.사진을 편집하고, 그래픽을 만들거나, 디지털 예술을 향상시키고 있는지 여부, 이것은방법은 이미지의 방향과 구성에 대한 정확한 통제를 제공합니다.그들이 당신의 창조적 인 비전을 쉽고 효율적으로 충족시키는 것을 보장합니다.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

로테이트 플립 유형

Examples

이 예제는 DJVU 이미지를 충전하고, 90도 시계로 회전하고, 선택적으로 이미지를 수평 및/또는 수직으로 니다.

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.Djvu.DjvuImage image = (Aspose.Imaging.FileFormats.Djvu.DjvuImage)Aspose.Imaging.Image.Load(dir + "sample.djvu"))
                                                                                                                                                  {
                                                                                                                                                      image.RotateFlip(rotateFlipType);
                                                                                                                                                      image.Save(dir + "sample." + rotateFlipType + ".png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                  }
                                                                                                                                              }

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

새로운 이미지 높이.

PropertyChanged

그것은 재산의 가치가 변할 때 발생합니다.

public event PropertyChangedEventHandler PropertyChanged

이벤트 유형

PropertyChangedEventHandler

 한국어