Class DjvuImage

Class DjvuImage

Název místa: Aspose.Imaging.FileFormats.Djvu Shromáždění: Aspose.Imaging.dll (25.4.0)

DjVu dokument třída podporuje grafický formát souboru a usnadňuje bezdrátovézení skenovaných dokumentů a knih, integrace textu, kresby, obrázk,a fotografie do jednoho formátu. podporou vícestránkových operací, můžeteefektivní přístup k jedinečným identifikátorům dokumentu, počítání stránek, nastavení aktivních stránek,a získat konkrétní dokumentové stránky. s funkcemi pro resing, rotating,dytování, hromadění, grayscale transformace, gamma korekce, úpravy,a filtruje aplikaci, tato třída umožňuje přesnou manipulaci a vylepšenísnímky DjVu k uspokojení různých požadavků aplikace s snadností a přesnost.

[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

Dědiční č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 příklad ukazuje, jak nahrát obrázek DJVU z souborového toku.

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čněte pracovat s obrázky DjVu iniciováním nové instanceAspose.Imaging.FileFormats.Djvu.DjvuImage třída pomocí parametr Stream.vývojáři, kteří chtějí bezproblémovou integraci zpracování obrazu DjVu dojejich projekt.

public DjvuImage(Stream stream)

Parameters

stream Stream

To je proud.

Examples

Tento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku.

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ázdný

DjvuImage(Přenos, LoadOptions)

Začněte pracovat s obrázky DjVu bezohledně s tímto konstruktorem, kterýzahájí nový příklad třídy Aspose.Imaging.FileFormats.Djvu.DjvuImage pomocí Stream aParametry LoadOptions. Ideální pro vývojáře, kteří chtějí přesnou kontrolu nadMožnosti nabíjení obrazu DjVu při zachování jednoduchosti a efektivity.

public DjvuImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Překrývka na nabit.

loadOptions LoadOptions

Možnosti nabíjen.

Examples

Tento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku, aby zůstal v rámci stanovené hranice paměti.

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ázdný

Properties

ActivePage

Navigace prostřednictvím vašeho dokumentu DjVu přístupem nebo nastavením aktuálně aktivníhoStránka používá tuto vlastnost. bezprostředně přejděte mezi stránkami, abyste se zaměřili na konkrétníObsah a zlepšení vašeho prohlížení dokumentů zkušenosti.

public DjvuPage ActivePage { get; set; }

Hodnota nemovitosti

DjvuPage

Examples

Tento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku a vytisknout informace o stránkách.

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

dná aktivní stránka není vybrána.

DjvuPages

Rychle získat všechny stránky obsažené ve vašem DjVu dokumentu pomocí tohotozjednodušit pracovní tok zpracování dokumentů snadným přístupem aspravovat jednotlivé stránky v souborech DjVu. zlepšit efektivitu aZjednodušujte své úkoly s pohodlným vyhledáváním stránek.

public DjvuPage[] DjvuPages { get; }

Hodnota nemovitosti

DjvuPage []a[]

FileFormat

Získejte informace o formátu souboru spojené s vaším souborem s obrázkem DjVu.určte formát souboru pro bezproblémovou integraci do vašeho pracovního toku.

public override FileFormat FileFormat { get; }

Hodnota nemovitosti

FileFormat

FirstPage

Připojte se k první stránce vašeho DjVu dokumentu s touto nemovitostí.vodní stránka začít zobrazovat nebo zpracovávat váš dokument efektivn.

public DjvuPage FirstPage { get; }

Hodnota nemovitosti

DjvuPage

Examples

Tento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku a vytisknout informace o stránkách.

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

První stránku nelze najít

HasAlpha

Rychle zjistit, zda váš obrazový soubor DjVu obsahuje alfa kanál.Zjednodušení pracovního toku kontrolou přítomnosti informací o transparentnostive vašich obrázcích.

public override bool HasAlpha { get; }

Hodnota nemovitosti

bool

Identifier

Získejte jedinečný identifikátor pro dokument

public int Identifier { get; }

Hodnota nemovitosti

int

LastPage

Obnovte poslední stránku vašeho DjVu dokumentu pomocí této nemovitosti.Poslední stránka pro snadné prohlížení nebo zpracování účel.

public DjvuPage LastPage { get; }

Hodnota nemovitosti

DjvuPage

Examples

Tento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku a vytisknout informace o stránkách.

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ánku nelze najít

NextPage

Navigujte prostřednictvím vašeho dokumentu DjVu tím, že se dostanete na další stránku s tímtopohodlné vlastnictví. rychle jít dopředu ve vašem prohlížení dokumentu nebozpracování úkol.

public DjvuPage NextPage { get; }

Hodnota nemovitosti

DjvuPage

Exceptions

DjvuImageException

Následující stránka se nenajde

PageCount

Obdržíte celkový počet stránek ve vaší sbírce obrázků DjVu s touto nemovitost.Ideální pro rychlé posouzení rozsahu vašeho dokumentu nebo knihy uloženého ve formátu DjVu.Zlepšete efektivitu vašeho pracovního toku přesnými informacemi o počtu stránek.

public override int PageCount { get; }

Hodnota nemovitosti

int

Pages

Připojte se k jednotlivým stránkám vaší sbírky obrázků DjVu s touto nemovitost.Zjednodušení navigace a manipulace s vaším dokumentem nebo knihou uloženým ve formátu DjVuprostřednictvím přístupu k každé stránce přímo. Zlepšete efektivitu vašeho pracovního toku snadnoStránka je zpětn.

public override Image[] Pages { get; }

Hodnota nemovitosti

Image []a[]

Examples

Tento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku.

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

Rychle se přesunete zpět do vašeho DjVu dokumentu prohlížení nebo zpracování úkolů pomocípřístup na předchozí stránku s touto výhodnou vlastností. efektivně navigovatProstřednictvím vašeho dokumentu snadno.

public DjvuPage PreviousPage { get; }

Hodnota nemovitosti

DjvuPage

Exceptions

DjvuImageException

Předchozí stránka nelze najít

Methods

AdjustBrightness(Int)

Přizpůsobte jasnost obrazu pomocí specifikovaného parametru, poskytující kontrolu nad hladinami osvětlení pro optimální vizuální jasnost. Tento metodický zesilovač snižuje celkovou jasnost obrazu, což umožňuje jemným úpravám dosáhnout požadovaných osvětlovacích efektů. Modulováním jasnosti mohou uživatelé optimalizovat viditelnost obrazu a zlepšit detailní reprodukci pro lepší prohlížen.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Světelná hodnota.

Examples

Následující příklad provádí jasnou korekci 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šení Aspose.Imaging.Image kontrastu ke zlepšení vizuální jasnosti azdůrazňuje detaily s touto metodou, která upravuje rozdíl v jasnosti mezisvětlé a tmavé oblasti. prostřednictvím jemně tónovaných kontrastních úrovní mohou uživatelé dosáhnout více živých aovlivňující snímky, zlepšuje celkovou kvalitu obrazu a maximalizuje viditelnost detail.Tato úprava pomáhá vytvářet jemné odstíny barvy a textury, což vede kDynamické a vizuálně atraktivní obrázky.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Kontrastní hodnota (v rozmezí [-100; 100])

Examples

Následující příklad provádí kontrastní korekci 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 korekce, zejména pro červené, zelené a modré kanály, zahrnuje úpravujasnost každé barevné složky odděleně. aplikováním různých gamaKoeficienty pro kanály RGB, můžete dokonale tónovat celkovou jasnost a kontrastTato technika zajišťuje přesnou barevnou reprezentaci a zlepšujeVizuální kvalita obrazu na různých displejních zařízeních.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Koeficient pro červené, zelené a modré kanály

Examples

Následující příklad provádí gamma korekci 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 korekce se aplikuje na obrázek s přizpůsobitelnými parametry pro červenou, zelenou,a modré kanály, které umožňují přesnou úpravu barvy a jasu.metoda zlepšuje kvalitu obrazu jemně tónovanou barevnou reprezentací, zajišťuje optimálníRenderování na různých displejních zařízeních. Přizpůsobení hodnot gama pro jednotlivéKanály zlepšují rovnováhu barev a vizuální přitažlivost.

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

Parameters

gammaRed float

Gamma pro koeficient červeného kanálu

gammaGreen float

Gamma pro koeficient zeleného kanálu

gammaBlue float

Gamma pro koeficient modrého kanálu

Examples

Následující příklad provádí gamma-korekci obrazu DJVU, který aplikuje různé koeficienty pro barevné 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)

Binarizace pomocí adaptivního algoritmu Bradleyho s integrovaným obrazemHranice je metoda, která vypočítá místní hranici pro každý pixel na základěmístní sousedství. přizpůsobuje se variacím v osvětlení přes obraz, čímžVhodné pro snímky s nerovnými světelnými podmínkami. pomocí výpočtu prahuintegrované snímky, účinně zachází s velkými sousedstvími, čímž je aplikován naV reálném čase aplikace. tato technika je běžně používána v zpracování dokumentů, OCR(Optical Character Recognition) a funkce segmentace obrazu, kde je přesnáBinaryzace je nezbytná pro následnou analýzu.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Rozdíl v jasu mezi pixelem a průměrem okna s x s pixelůSkládá se kolem tohoto pixelu.

windowSize int

Velikost okna s x s pixely soustředěné kolem tohoto pixelu

Examples

Následující příklad binarizuje obrázek DJVU s adaptativním algoritmem Bradleyho s specifikovanou velikostí 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)

Binarizace s předdefinovaným prahem zjednodušuje složité obrázky do binárníhozobrazení, kde jsou pixely klasifikovány jako černé nebo bílé na základě jejichv porovnání s určitou prahovou hodnotou. tato technika se běžně používá vzpracování obrazu pro zvýšení jasnosti, zjednodušení analýzy a přípravu obrázků pro dalšípostupy zpracování, jako je optické rozpoznávání charakteru (OCR).hranici, můžete rychle transformovat grayscale obrazy do binární formy, dělat jeJe snadnější interpretovat a extrahovat smysluplné informace.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Pokud odpovídající šedá hodnota pixelů je větší než hranici, hodnota255 bude k němu přiděleno, 0 jinak.

Examples

Následující příklad binarizuje obrázek DJVU s předdefinovaným prahem. binarizované obrázky obsahují pouze 2 barvy - černou a bílou.

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

Binarizace pomocí Otsu prahu je technika, která automaticky vypočítáoptimální limitní hodnota založená na histogramu obrazu. odděluje obraz dopřední a pozadí minimalizováním intra-klasa variance.Široko používané pro segmentování obrázků do binární formy, zejména při distribuciPixelové intenzity jsou bimodální nebo multimodální.Tento přístup je prospěšný pro úkolyjako je detekce objektů, segmentace obrazu a extrakce vlastností, kde je přesnáRozdíl mezi předním a pozadím je velmi důležit.

public override void BinarizeOtsu()

Examples

Následující příklad binaryzuje obrázek DJVU s Otsu hranicí. binaryzované obrázky obsahují pouze 2 barvy - černá a bíl.

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

Cache data soukromě optimalizovat výkon a snížit potřebu opakovaných datZvrat z externích zdrojů.Tento přístup také pomáhá zachovat zdroje,Zvláště v scenářích, kdy je přístup k datům častý nebo jsou zdroje omezen.

public override void CacheData()

Examples

Následující příklad ukazuje, jak ukázat všechny 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” odesílá váš obrázek, aby se zaměřil na konkrétní detaily nebo odstranil nežádoucí prvky,zlepšení jeho složení a vizuální dopad. zda upravujete fotografie pro sociálnímedia, vytváření webové stránky bannery, nebo navrhování tiskových materiálů, tento nástroj vám pomůžeOpravte své obrázky s přesností a jasnost.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

V pravém úhlu.

Examples

Následující příklad pěstuje obrázek DJVU. Pěstovací oblast je specifikována prostřednictvím 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)

Rostlina s přechody vám umožňuje přesně upravit polohu a rozměryhromadná plocha uvnitř obrazu. Tato funkce je neocenitelná pro rafinování kompozic,přizpůsobení prvků a zdůrazňování fokusových bodů ve vašich vizualizacích.do procesu hromadění, můžete dosáhnout dokonalé přesnosti pixelů a jemné tónováníVytvořte si své obrázky snadno.

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

Parameters

leftShift int

Vlevo se měn.

rightShift int

Na správnou změnu.

topShift int

V horním směru.

bottomShift int

V dolním směru.

Dither(DitheringMetoda, int, IColorPalette)

Funkce “Dither” aplikuje do vašeho obrazu dithering efekt, který zlepšuje jeho vizuálníkvalita tím, že snižuje pásky a zlepšuje barevné přechody.pro digitální umění, fotografie nebo grafický design, tato funkce přidáváprofesionální dotyk k vašim obrázkům, takže se zdají hladší a rafinovaněj.

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

Parameters

ditheringMethod DitheringMethod

Způsob rozptýlen.

bitsCount int

Poslední bity počítají na dithering.

customPalette IColorPalette

Závěrečná paleta pro dytován.

Examples

Následující příklad nabírá obrázek DJVU a provádí hranici a vlhkost s použitím různé hloubky 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(Rektangle, FilterOptionsBase)

Aplikujte filtry na určitou rektangulární oblast v obrazu, aby se zlepšila nebo změnila jehocílením konkrétních oblastí umožňuje tato metoda přesné úpravy,jako je blurování, ostrování nebo uplatňování uměleckých efektů, k dosažení požadovaného vizuálníhoFine-tuning filtry na vybraných oblastech umožňují uživatelům přizpůsobit obrázekestetika, zlepšuje jasnost a vytváří umělecké efekty přizpůsobené jejich preferencím.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

V pravém úhlu.

options FilterOptionsBase

Tyto možnosti.

Examples

Následující příklad se vztahuje na různé typy filtrů na obrázek 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 transformace přeměňuje obraz na černobílou reprezentaci, kdeIntenzita každého pixelu je reprezentována jednotnou hodnotou od černé do bíl.Tento proces odstraňuje informace o barvě, což vede k monochromatickému obrazu.obrazy jsou běžně používány v aplikacích, kde je barva nepotřebná nebo kde je jednoduchostje upřednostňován, jako je skenování dokumentů, tisk a určité typy analýzy obrazu.

public override void Grayscale()

Examples

Následující příklad přeměňuje barevný obrázek DJVU na jeho grayscale reprezentaci. Grayscale obrazy se skládají výhradně ze odstínů šedé a nesou pouze informace o intenzit.

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)

Stáhněte si dokument DjVu pomocí této metody. Streamline váš proces rychlepřístup a import DjVu souborů do vaší aplikace.

public static DjvuImage LoadDocument(Stream stream)

Parameters

stream Stream

To je proud.

Returns

DjvuImage

Přehrávač dokumentů Djvu

LoadDocument(Přenos, LoadOptions)

Import DjVu dokumentu pomocí této metody s stream a loadOptionsparametry. streamline váš proces rychlým přístupem a dovozem DjVu souborůdo vaší aplikace, které poskytují flexibilitu a možnosti přizpůsobeníVaše potřeby.

public static DjvuImage LoadDocument(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

To je proud.

loadOptions LoadOptions

Možnosti nabíjen.

Returns

DjvuImage

Přehrávač dokumentů Djvu

ReleaseManagedResources()

Uvolňuje spravované zdroje. ujistěte se, že zde nejsou zveřejněny žádné nezveřejněné zdroje, protože mohou býtUž byl propuštěn.

protected override void ReleaseManagedResources()

Resize(int, int, resizeType)

Obnovte obrázek pomocí Resize Metoda, která poskytuje jednoduchý a efektivní způsobpřizpůsobit rozměry vašich obrázků podle vašich požadavků.univerzální funkce vám umožní snadno rozšiřovat obrázky na požadovanou velikost,Posílení jejich použitelnosti na různých platformách a aplikacích.

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

Parameters

newWidth int

A nová šířka.

newHeight int

A nová výška.

resizeType ResizeType

Tyto typy jsou recidivn.

Examples

Tento příklad nahrává obrázek DJVU a recidivuje ho pomocí různých recidivních metod.

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(snímky, snímky, snímky)

Obnovte obrázek na specifikovanou šířku a výšku při aplikaci dalších nastaveníTato metoda umožňuje uživatelům upravit rozměry obrazu přizachování požadovaných atributů, jako je poměr aspektu, kvalita obrazu a kompresenastavení. poskytnutím flexibility v možnosti recenzi, uživatelé mohou přizpůsobit obrázek kvyhovuje specifickým požadavkům a optimalizuje jeho vzhled pro různé aplikace ana platformách.

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

Parameters

newWidth int

A nová šířka.

newHeight int

A nová výška.

settings ImageResizeSettings

Zpětné nastaven.

Examples

Tento příklad nahrává obrázek DJVU a resize ho pomocí různých resizing 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(Zpět, ResizeType)

The ResizeHeightProportionally Metoda vám umožňuje upravit výšku vašehosnímku při zachování jejího poměru vzhledu. to zajišťuje, že váš obrázek udržujejeho proporce, zabránit zkreslení a zachovat jeho vizuální celistvost.Ať už optimalizujete obrázky pro webové stránky, mobilní aplikace nebo tiskové média, totoMetoda zajišťuje, že vaše obrázky vypadají nejlépe na různých platformách a zařízeních.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

A nová výška.

resizeType ResizeType

Druh odrůdy.

Examples

Tento příklad nahrává obrázek DJVU a proporčně ho resizuje pomocí různých resizačních metod. Pouze výška je stanovena, šířka se automaticky vypočít.

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(Zpět, ResizeType)

The ResizeWidthProportionally Metoda poskytuje pohodlné řešení pro úpravušířka vašeho obrazu při zachování jeho vztahu vzhledu.v šířce, můžete zajistit, že vaše obrazy zůstávají vizuálně atraktivní akonzistentní na různých zařízeních a velikostech obrazovky, čímž se zvyšuje jejich všestrannostPoužití v různých kontextech.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

A nová šířka.

resizeType ResizeType

Druh odrůdy.

Examples

Tento příklad nahrává obrázek DJVU a proporčně ho resizuje pomocí různých resizačních metod. Pouze šířka je specifikována, výška je automaticky vypočítána.

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(plavba, bool, barva)

Obrátit obrázek kolem jeho centra pomocí rotační metodyRasterCachedMultipageImage třída. tato pohodlná funkce umožňuje snadnopřizpůsobit orientaci snímků při zachování jejich centrální polohy,Zlepšování schopností manipulace s obrazem.

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

Parameters

angle float

Otevírací úhel v stupních. pozitivní hodnoty se otáčí po hodin.

resizeProportionally bool

Pokud je nastaven na “skutečný”, budete mít velikost obrazu změněna v závislosti na rotačních rektangle (kornové body) projekce v jiném případě, které zanechávají rozměry nedotčené a pouzevnitřní obsah obrazu jsou rotačn.

backgroundColor Color

Barva pozad.

RotateFlip(RotateFlipType)

The RotateFlip metoda nabízí všestranné možnosti manipulace vašeho obrazu, umožňujícímůžete otáčet, flip, nebo provádět obě operace na aktivním rámu nezávisle.Ať už upravujete fotografie, vytváříte grafiku nebo vylepšujete digitální umění, totometoda poskytuje přesnou kontrolu orientace a složení vašich obrázk,Ujistěte se, že splňují vaši tvůrčí vizi s lehkostí a efektivitou.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Typ rotujícího flip.

Examples

Tento příklad nahrává obrázek DJVU, otáčí ho o 90 stupňů hodinově a volitelně flipsuje obrázek horizontálně a/nebo vertikáln.

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)

Ušetříme data.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Příliv pro ukládání dat.

UpdateDimensions(a int, int)

Aktualizace rozměrů obrazu.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Nové obrazové šířky.

newHeight int

Nová výška obrazu.

PropertyChanged

Stává se, když se hodnota nemovitosti měn.

public event PropertyChangedEventHandler PropertyChanged

Typ události

PropertyChangedEventHandler

 Čeština