Class DjvuImage

Class DjvuImage

Pôvodný názov: Aspose.Imaging.FileFormats.Djvu Zhromaždenie: Aspose.Imaging.dll (25.4.0)

DjVu dokumentová trieda podporuje grafický formát súboru a uľahčuje bezchybnériadenie skenovaných dokumentov a kníh, integrácia textu, výkresov, obrázkov,a fotografie do jedného formátu. podporou viacstránkových operácií, môžeteefektívny prístup k jedinečným identifikátorom dokumentu, počítanie strán, nastavenie aktívnych stránok,a získať špecifické dokumentové stránky. s funkciami pre resing, rotačné,dytovanie, kopanie, transformácia grayscale, gamma korekcie, úpravy,a filtre aplikácie, táto trieda umožňuje presnú manipuláciu a zlepšeniesnímky DjVu na uspokojenie rôznych aplikácií s ľahkosťou a presnosťou.

[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

Z dedičných členov

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

Tento príklad ukazuje, ako nahrať obrázok DJVU z prúdu súborov.

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)

Začnite pracovať s obrázkami DjVu iniciovaním novej inštancieAspose.Imaging.FileFormats.Djvu.JvuImage trieda pomocou parametra Stream.vývojári, ktorí chcú bezproblémovú integráciu spracovania obrazu DjVu doich projektov .

public DjvuImage(Stream stream)

Parameters

stream Stream

a prúdu .

Examples

Tento príklad ukazuje, ako nahrať obrázok DJVU z prúdu súborov.

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

Stream je prázdny

DjvuImage(Príslušenstvo, LoadOptions)

Začnite pracovať s obrázkami DjVu bezchybne s týmto konštruktorom, ktorýinicializuje nový príklad triedy Aspose.Imaging.FileFormats.Djvu.JvuImage pomocou Stream aParametre LoadOptions. Ideálne pre vývojárov, ktorí chcú presnú kontrolu nadMožnosti načítania obrazu DjVu pri zachovaní jednoduchosti a efektívnosti.

public DjvuImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Prúd na nabitie od.

loadOptions LoadOptions

Možnosti zaťaženia .

Examples

Tento príklad ukazuje, ako nahrať obrázok DJVU z toku súborov, aby zostali v rámci stanoveného limitu pamäte.

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

Stream je prázdny

Properties

ActivePage

Prehliadajte svoj DjVu dokument prístupom alebo nastavením aktuálne aktívnehoStránka používa túto vlastnosť. bezproblémovo prepínajte medzi stránkami, aby ste sa zameriavali na špecifickéobsah a zlepšenie vašej skúsenosti s prehliadkou dokumentov.

public DjvuPage ActivePage { get; set; }

Hodnota nehnuteľnosti

DjvuPage

Examples

Tento príklad ukazuje, ako nahrať obrázok DJVU z toku súborov a vytlačiť informácie o stránkach.

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

Neexistuje žiadna aktívna stránka vybraná.

DjvuPages

Rýchlo získajte všetky stránky obsiahnuté vo vašom DjVu dokumente pomocou tohtoZjednodušenie pracovného toku spracovania dokumentov jednoduchým prístupom aspravovať jednotlivé stránky v súboroch DjVu. zlepšiť efektívnosť aZjednodušujte svoje úlohy s pohodlným návratom stránky.

public DjvuPage[] DjvuPages { get; }

Hodnota nehnuteľnosti

DjvuPage []

FileFormat

Získajte informácie o formáte súboru spojené s vašim DjVu obrázok súbory.určte formát vášho súboru pre bezproblémovú integráciu do pracovného toku.

public override FileFormat FileFormat { get; }

Hodnota nehnuteľnosti

FileFormat

FirstPage

Prístup na prvú stránku vášho DjVu dokumentu s touto vlastnosťou.na počiatočnú stránku, aby ste začali efektívne zobrazovať alebo spracovávať dokument.

public DjvuPage FirstPage { get; }

Hodnota nehnuteľnosti

DjvuPage

Examples

Tento príklad ukazuje, ako nahrať obrázok DJVU z toku súborov a vytlačiť informácie o stránkach.

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

Prvá stránka sa nenachádza

HasAlpha

Rýchlo zistiť, či váš obrazový súbor DjVu obsahuje alfa kanál.Zjednodušenie pracovného toku kontrolou prítomnosti informácií o transparentnostiv tvojom obraze.

public override bool HasAlpha { get; }

Hodnota nehnuteľnosti

bool

Identifier

Získa jedinečný identifikátor pre dokument

public int Identifier { get; }

Hodnota nehnuteľnosti

int

LastPage

Obnoviť poslednú stránku svojho DjVu dokumentu pomocou tejto nehnuteľnosti.Posledná stránka pre zobrazenie alebo spracovanie účelov s ľahkosťou.

public DjvuPage LastPage { get; }

Hodnota nehnuteľnosti

DjvuPage

Examples

Tento príklad ukazuje, ako nahrať obrázok DJVU z toku súborov a vytlačiť informácie o stránkach.

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

Posledná stránka sa nenachádza

NextPage

Prejdite cez svoj dokument DjVu prístupom na ďalšiu stránku s týmtopohodlná nehnuteľnosť. rýchlo sa presunúť v prehliadke dokumentu alebospracovanie úloh .

public DjvuPage NextPage { get; }

Hodnota nehnuteľnosti

DjvuPage

Exceptions

DjvuImageException

Nasledujúca stránka sa nenachádza

PageCount

Získajte celkový počet stránok vo svojej zbierke obrázkov DjVu s touto vlastnosťou.Ideálne pre rýchle posúdenie rozsahu dokumentu alebo knihy uloženého vo formáte DjVu.Zlepšujte efektívnosť vášho pracovného toku s presnými informáciami o počte stránok.

public override int PageCount { get; }

Hodnota nehnuteľnosti

int

Pages

Prístup k jednotlivým stránkam vašej zbierky obrázkov DjVu s touto vlastnosťou.Zjednodušenie navigácie a manipulácie s dokumentom alebo knihou uloženými vo formáte DjVuprostredníctvom prístupu k každej stránke priamo. Zlepšiť efektívnosť vášho pracovného toku s ľahkosťouStránka na stiahnutie.

public override Image[] Pages { get; }

Hodnota nehnuteľnosti

Image []

Examples

Tento príklad ukazuje, ako nahrať obrázok DJVU z prúdu súborov.

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

Rýchlo sa presunú späť do vášho dokumentu DjVu zobrazenie alebo spracovanie úloh prostredníctvomprístup na predchádzajúcu stránku s touto pohodlnou vlastnosťou. efektívne navigovaťProstredníctvom vášho dokumentu s ľahkosťou.

public DjvuPage PreviousPage { get; }

Hodnota nehnuteľnosti

DjvuPage

Exceptions

DjvuImageException

Predchádzajúca stránka sa nenachádza

Methods

AdjustBrightness(int)

Prispôsobte jas " obrazu pomocou špecifikovaného parametru, poskytujú kontrolu nad hladinami osvetlenia pre optimálnu vizuálnu jasnosť. Táto metóda posilňovač znižuje celkovú lesk obrazov, čo umožňuje, aby jemné úpravy dosiahli požadované svetelné efekty. Moduláciou jasu môžu používatelia optimalizovať viditeľnosť a zlepšiť detailnú reprodukciu pre lepšiu skúsenosť s videním.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Hodnoty jasnosti .

Examples

Nasledujúci príklad vykonáva jasnú korekciu obrazu 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(flotila)

Zlepšenie Aspose.Imaging.Image kontrast na zlepšenie vizuálnej jasnosti azdôrazňuje detaily pomocou tejto metódy, ktorá upravuje rozdiel v jasnosti medzisvetlé a tmavé oblasti. jemne tónovanými kontrastnými úrovňami môžu používatelia dosiahnuť viac živých aovplyvňujúce obrázky, zlepšenie celkovej kvality obrazu a maximalizácia viditeľnosti detailov.Táto úprava pomáha vytvoriť jemné nuansy farby a textúry, čo vedie kviac dynamických a vizuálne atraktívnych obrazov.

public override void AdjustContrast(float contrast)

Parameters

contrast float

kontrastná hodnota (v rozmedzí [-100; 100])

Examples

Nasledujúci príklad vykonáva kontrastnú korekciu obrazu 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(flotila)

Gamma korekcia, konkrétne pre červené, zelené a modré kanály, zahŕňa úpravujasnosť každej farebnej zložky samostatne. aplikáciou rôznych gamaKoeficienty RGB kanálov, môžete zdokonaľovať celkovú jasnosť a kontrastTáto technika zabezpečuje presnú farebnú reprezentáciu a zlepšujeVizuálna kvalita obrazu cez rôzne displeje.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma pre červené, zelené a modré kanály koeficient

Examples

Nasledujúci príklad vykonáva gamma korekciu obrazu 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(plavba, plavba, plavba)

Gamma korekcia sa aplikuje na obrázok s prispôsobiteľnými parametrami pre červenú, zelenúa modré kanály, ktoré umožňujú presnú úpravu farebnej rovnováhy a jasu.metóda zlepšuje kvalitu obrazu jemnou tónovanou farebnou reprezentáciou, zaisťuje optimálnerenderovanie cez rôzne displejové zariadenia. prispôsobenie gamma hodnôt pre jednotlivcovKanály zlepšujú farebnú rovnováhu a vizuálnu príťažlivosť.

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

Parameters

gammaRed float

Gamma pre červený kanál koeficient

gammaGreen float

Gamma pre zelený kanál koeficient

gammaBlue float

Gamma pre modrý kanál koeficient

Examples

Nasledujúci príklad vykonáva gamma korekciu obrazu DJVU, ktorý aplikuje rôzne koeficienty na farebné komponenty.

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(dvojnásobný, int)

Binarizácia pomocou Bradleyho adaptívneho prahového algoritmu s integrovaným obrazomHranica je metóda, ktorá vypočíta lokálnu hranicu pre každý pixel na základemiestne okolie. prispôsobuje sa variáciám v osvetlení cez obrázok, čím saVhodný pre obrázky s nerovnomernými svetelnými podmienkami. počítať prah pomocouintegrované obrazy, efektívne sa zaoberá veľkými oblasťami, čím sa uplatňuje naV reálnom čase aplikácie. Táto technika sa bežne používa v spracovaní dokumentov, OCR(Optical Character Recognition) a úlohy segmentácie obrazu, kde je presnáBinárnosť je nevyhnutná pre následnú analýzu.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Rozdiel jasu medzi pixelom a priemerným oknom s x s pixlovSústrediť sa okolo tohto pixel.

windowSize int

Veľkosť okna s x s pixelov sústredených okolo tohto pixelov

Examples

Nasledujúci príklad binarizuje obrázok DJVU s adaptívnym algoritmom Bradleyho s špecifikovanou veľkosťou okna.

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

Binarizácia s preddefinovaným prahom zjednodušuje komplexné obrazy na binárnereprezentácie, kde sú pixely klasifikované ako čierne alebo biele na základe ichintenzita v porovnaní so stanovenou prahovou hodnotou. táto technika sa bežne používa vspracovanie obrazu na zvýšenie jasnosti, zjednodušenie analýzy a prípravu obrázkov na ďalšiepostupy spracovania, ako je optické rozpoznávanie charakteru (OCR).Hranice, môžete rýchlo premeniť obrázky na hrubú škálu na binárne tvary, aby ichľahšie interpretovať a extrahovať zmysluplné informácie.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Ak je príslušná šedá hodnota pixelov väčšia ako hranica, hodnotou255 bude k nemu pridelených, 0 inak.

Examples

Nasledujúci príklad binarizuje obrázok DJVU s preddefinovaným prahom. binárne obrázky obsahujú iba 2 farby - čierna a biela.

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

Binarizácia pomocou Otsu hranici je technika, ktorá automaticky vypočítaoptimálna hraničná hodnota založená na histograme obrazu.predné a pozadie minimalizáciou intra-trieda variácie.široko používané na segmentovanie obrázkov do binárnej formy, najmä pri distribúciipixelové intenzity sú bimodálne alebo multimodálny. tento prístup je prospešný pre úlohyako je detekcia objektov, segmentácia obrazu a extrakcia funkcií, kde je presnáRozlíšenie medzi predpokladom a pozadím je rozhodujúce.

public override void BinarizeOtsu()

Examples

Nasledujúci príklad binarizuje obrázok DJVU s Otsu hranice. binárne obrázky obsahujú iba 2 farby - čierna a biela.

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

Súkromné ukladanie údajov na optimalizáciu výkonu a zníženie potreby opakovaných údajovZískanie z vonkajších zdrojov.Tento prístup tiež pomáha zachovať zdroje,Zvlášť v scenároch, keď je prístup k údajom častý alebo sú zdroje obmedzené.

public override void CacheData()

Examples

Nasledujúci príklad ukazuje, ako skryť všetky stránky obrázku 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)

“Crop” odošle váš obrázok so zameraním na konkrétne detaily alebo odstránenie nežiaducich prvkov,zlepšiť jeho zloženie a vizuálny vplyv. či upravujete fotografie pre sociálnemédiá, vytváranie webové bannery, alebo navrhovanie tlačených materiálov, tento nástroj vám pomôžeZlepšujte svoje obrázky s presnosťou a jasnosťou.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

v pravom rohu.

Examples

V nasledujúcom príklade sa zobrazí obrázok DJVU. Oblasť pestovania sa určuje prostredníctvom 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(int, int, int, int, int)

Rastliny s posunmi vám umožňujú presne upraviť polohu a rozmeryhrobená oblasť vo vnútri obrazu. Táto funkcia je neoceniteľná pre rafinovanie kompozícií,zosúladenie prvkov, a zdôrazňovanie bodov v vašich vizuálov.do procesu vykopávky, môžete dosiahnuť pixel-perfektnú presnosť a jemne tónovaťVytvorte si svoje obrázky ľahko.

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

Parameters

leftShift int

Vľavo sa mení.

rightShift int

Príslušná zmena .

topShift int

Najvyššia výmena.

bottomShift int

V dolnej posune.

Dither(DitheringMetóda, int, IColorPalette)

Funkcia “Dither” sa vzťahuje na váš obraz a zlepšuje jeho vizuálny efekt.kvalita znížením zväzku a zlepšovaním farebných prechodov. či pracujetena projekty digitálneho umenia, fotografie alebo grafického dizajnu, táto funkcia pridáprofesionálny dotyk na vaše obrázky, čo ich robí vyzerať hladšie a viac rafinované.

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

Parameters

ditheringMethod DitheringMethod

Metóda rozptýlenia .

bitsCount int

Posledné bity počítajú na dithering.

customPalette IColorPalette

Zvyčajná paleta pre dithering.

Examples

Nasledujúci príklad nahráva obrázok DJVU a vykonáva hraničné a plynulé dithering pomocou rôznych hĺbok palety.

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(Rectangle, FilterOptionsBase)

Aplikujte filtre na špecifikovanú rektangulárnu oblasť vo vnútri obrazu, aby sa zlepšila alebo zmenila jehocieľom konkrétnych regiónov, táto metóda umožňuje presné úpravy,ako je blúrenie, zosilňovanie alebo aplikácia umeleckých efektov na dosiahnutie požadovanej vizuálnejFine-tuning filtre na vybraných oblastiach umožňujú používateľom prispôsobiť obrázokestetiky, zlepšuje jasnosť a vytvára umelecké efekty prispôsobené ich preferenciám.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

v pravom rohu.

options FilterOptionsBase

a možnosťami .

Examples

Nasledujúci príklad sa vzťahuje na rôzne typy filtrov na obrázok 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 transformácia premieňa obrázok na čierno-bielu reprezentáciu, kdeIntenzita každého pixelov je reprezentovaná jednotnou hodnotou, ktorá sa pohybuje od čierneho do bieleho.Tento proces odstraňuje informácie o farbe, čo vedie k monochromatickému obrazu.obrazy sa bežne používajú v aplikáciách, kde je farba zbytočná alebo kde jednoduchosťje preferovaná, ako je skenovanie dokumentov, tlač a určité typy analýzy obrazu.

public override void Grayscale()

Examples

Nasledujúci príklad premení farebný obrázok DJVU na jeho šedivý obraz. Grayscale obrazy sú zložené výlučne zo odtieňov sivej a nesú iba intenzitu informácií.

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)

Nahrať svoj DjVu dokument pomocou tejto metódy. Streamline váš proces rýchloprístup a import súborov DjVu do vašej aplikácie.

public static DjvuImage LoadDocument(Stream stream)

Parameters

stream Stream

a prúdu .

Returns

DjvuImage

Naložené djvu dokumenty

LoadDocument(Príslušenstvo, LoadOptions)

Importovať váš DjVu dokument pomocou tejto metódy s stream a loadOptionsStreamline váš proces rýchlym prístupom a importom DjVu súborovdo vašej aplikácie, poskytujú flexibilitu a možnosti prispôsobenia na splnenieVaše potreby .

public static DjvuImage LoadDocument(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

a prúdu .

loadOptions LoadOptions

Možnosti zaťaženia .

Returns

DjvuImage

Naložené djvu dokumenty

ReleaseManagedResources()

Uvoľňuje spravované zdroje. uistite sa, že žiadne nezamestnané prostriedky nie sú uvoľnené tu, pretože môžu byťUž bola prepustená.

protected override void ReleaseManagedResources()

Resize(int, int, resizeType)

Obnoviť obrázok pomocou Resize Metóda, ktorá poskytuje jednoduchý a efektívny spôsobprispôsobiť rozmery obrázkov podľa vašich požiadaviek.všestranná funkcia vám umožňuje ľahko rozširovať obrázky do požadovanej veľkosti,Zvýšenie ich použiteľnosti na rôznych platformách a aplikáciách.

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

Parameters

newWidth int

a novú šírku.

newHeight int

a novú výšku.

resizeType ResizeType

To je reza typ.

Examples

Tento príklad nahráva obrázok DJVU a resizuje ho pomocou rôznych metód resingu.

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(int, int, ImageResizeSettings)

Obnoviť obrázok na špecifikovanú šírku a výšku pri aplikácii ďalších nastaveníTáto metóda umožňuje používateľom prispôsobiť rozmery obrazu, zatiaľ čozachovanie požadovaných atribútov, ako je pomer hľadiska, kvalita obrazu a kompresiaNastavenia. poskytnutím flexibility v možnostiach recenzií môžu používatelia prispôsobiť obrázok naspĺňa špecifické požiadavky a optimalizuje jej vzhľad pre rôzne aplikácie ana platformách .

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

Parameters

newWidth int

a novú šírku.

newHeight int

a novú výšku.

settings ImageResizeSettings

Odstránené nastavenia .

Examples

Tento príklad nahráva obrázok DJVU a resizuje ho pomocou rôznych rezingových nastavení.

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(Inštalácia, ResizeType)

The ResizeHeightProportionally metóda umožňuje prispôsobiť výšku vašejobraz pri zachovaní jeho aspektového pomeru. to zaručuje, že váš obraz zachovávajeho proporcie, zabraňujú zhoršeniu a zachovávajú jeho vizuálnu integritu.Či už optimalizujete obrázky pre webové stránky, mobilné aplikácie alebo tlačové médiá, totometóda zabezpečuje, že vaše obrázky vyzerajú najlepšie na rôznych platformách a zariadeniach.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

a novú výšku.

resizeType ResizeType

Druh revízie .

Examples

Tento príklad nahráva obrázok DJVU a resizuje ho primerane pomocou rôznych resizačných metód. Len výška je určená, šírka sa automaticky vypočíta.

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(Inštalácia, ResizeType)

The ResizeWidthProportionally Metóda poskytuje pohodlné riešenie na prispôsobeniešírka vášho obrazu pri zachovaní jeho vzhľadu.v šírke, môžete zabezpečiť, aby vaše obrázky zostali vizuálne atraktívne akonzistentné v rôznych zariadeniach a veľkostiach obrazovky, čím sa zvyšuje ich všestrannosťPoužitie v rôznych kontextoch.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

a novú šírku.

resizeType ResizeType

Druh revízie .

Examples

Tento príklad nahráva obrázok DJVU a resizuje ho primerane pomocou rôznych resizačných metód. Len šírka je určená, výška sa automaticky vypočíta.

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(Float, bool, farba)

Obráťte obrázok okolo jeho centra pomocou metódy rotácieRasterCachedMultipageImage trieda. táto pohodlná funkcia vám umožňuje ľahkonastaviť orientáciu obrázkov pri zachovaní ich centrálnej polohy,Zlepšenie schopností manipulácie s obrazom.

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

Parameters

angle float

Zvuk sa otáča v stupňoch. pozitívne hodnoty sa otáčajú hodinovo.

resizeProportionally bool

v prípade nastavenia na “skutočné” sa zmení veľkosť obrazu podľa rotujúcich rektangulárnych (kornových bodov) projekcií v inom prípade, ktoré zanechávajú rozmery bez dotyku a ibavnútorné obrázkové obsahu sa rotuje.

backgroundColor Color

Farba z pozadia.

RotateFlip(RotateFlipType)

The RotateFlip metóda ponúka všestranné možnosti manipulácie pre váš obraz, čo umožňujemôžete otáčať, flip, alebo vykonávať obe operácie na aktívnom rámu nezávisle.Či už upravujete fotografie, vytvárate grafiku alebo zdokonaľujete digitálne umenie, totometóda poskytuje presnú kontrolu orientácie a zloženia vašich obrázkov,Uistite sa, že spĺňajú vašu kreatívnu víziu ľahko a efektívne.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Rotačný typ flip.

Examples

Tento príklad nahrádza obrázok DJVU, otáča ho o 90 stupňov na hodinky a voliteľne flips obraz horizontálne a/alebo vertikálne.

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)

Šetrí sa dáta.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Stream na ukladanie údajov.

UpdateDimensions(a int, int)

Aktualizujte rozmery obrazu.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Nový obrázok šírka.

newHeight int

Nová výška obrazu.

PropertyChanged

Stáva sa, keď sa mení hodnota nehnuteľnosti.

public event PropertyChangedEventHandler PropertyChanged

Typ udalosti

PropertyChangedEventHandler

 Slovenčina