Class DjvuImage

Class DjvuImage

A név: Aspose.Imaging.FileFormats.Djvu Összefoglaló: Aspose.Imaging.dll (25.4.0)

A DjVu dokumentumosztály támogatja a grafikus fájlformátumot, és könnyen használhatószkennelt dokumentumok és könyvek kezelése, szöveg, rajzok, képek integrálása,és fényképek egyetlen formátumban. többoldalú műveletek támogatásával,hatékonyan hozzáférhet az egyedi dokumentum azonosítókhoz, számoljon oldalakat, állítsa be az aktív oldalt,és visszavonja a konkrét dokumentum oldalakat. funkciókkal az újraindításhoz, a forgatáshoz,Dithering, kopás, grayscale átalakítás, gamma korrekciók, kiigazítások,és szűrő alkalmazás, ez az osztály lehetővé teszi a pontos manipuláció és javításDjVu képek, hogy megfeleljen a különböző alkalmazási igények könnyű és pontos.

[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

Örökletes tagok

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

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától.

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)

Kezdje a munkát a DjVu képek kezdeményezésével egy új példányt aAspose.Imaging.FileFormats.Djvu.JvuImage osztály a Stream paraméter használatával.olyan fejlesztők, akik a DjVu képfeldolgozás szűk integrációját szeretnékAz ő projektek.

public DjvuImage(Stream stream)

Parameters

stream Stream

Az áramlás.

Examples

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától.

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

Az áram üres

DjvuImage(Áramlat, LoadOptions)

Kezdje a munkát a DjVu képekkel szétválaszthatatlanul ezzel a konstruktőrrel, amelykezdeményez egy új Aspose.Imaging.FileFormats.Djvu.JvuImage osztály példája Stream ésLoadOptions paraméterek. tökéletes azoknak a fejlesztőknek, akik pontos ellenőrzést akarnakDjVu kép töltő opciók, miközben egyszerűségét és hatékonyságát.

public DjvuImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Az áramlást el kell tölteni.

loadOptions LoadOptions

A terhelési lehetőségek.

Examples

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától, hogy a megadott memória határain belül maradjon.

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

Az áram üres

Properties

ActivePage

Navigáljon a DjVu dokumentumon keresztül azáltal, hogy hozzáfér vagy beállítja a jelenleg aktívoldal használja ezt a tulajdonságot. szigorúan áthelyezze az oldalak között, hogy összpontosítson egy adotttartalom és javítja a dokumentum megtekintési élményt.

public DjvuPage ActivePage { get; set; }

ingatlan értéke

DjvuPage

Examples

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától és nyomtatni az oldalakról szóló információkat.

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

Nincs aktív oldal kiválasztva.

DjvuPages

Gyorsan visszavonja az összes oldalát a DjVu dokumentumban ezt használvaA dokumentum feldolgozásának munkafolyamatának egyszerűsítése a könnyen hozzáférhető ésaz egyes oldalak kezelése a DjVu fájlokon belül. javítja a hatékonyságot ésA feladatok egyszerűsítése kényelmes oldalvisszatérítéssel.

public DjvuPage[] DjvuPages { get; }

ingatlan értéke

DjvuPage []

FileFormat

Szerezze meg a fájlformátumot információkat kapcsolódik a DjVu képfájlt.határozza meg a fájl formátumát a munkafolyamatba való homályos integrációhoz.

public override FileFormat FileFormat { get; }

ingatlan értéke

FileFormat

FirstPage

Hozzáférés az első oldalon a DjVu dokumentum ezzel a tulajdonsággal.a kezdeti oldalon, hogy elkezdje megnézni vagy feldolgozni a dokumentum hatékonyan.

public DjvuPage FirstPage { get; }

ingatlan értéke

DjvuPage

Examples

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától és nyomtatni az oldalakról szóló információkat.

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

Az első oldal nem található

HasAlpha

Gyorsan meghatározza, hogy a DjVu képfájl tartalmaz-e egy alfa csatornát.Egyszerűsíti a munkafolyamatot az átláthatósági információk jelenlétének ellenőrzésévelAz Ön képében.

public override bool HasAlpha { get; }

ingatlan értéke

bool

Identifier

Megkapja a dokumentum egyedi azonosítóját

public int Identifier { get; }

ingatlan értéke

int

LastPage

Visszaállítsa a DjVu dokumentumának utolsó oldala ezt a tulajdonságot használva.A végoldal könnyen megtekinthető vagy feldolgozható célokra.

public DjvuPage LastPage { get; }

ingatlan értéke

DjvuPage

Examples

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától és nyomtatni az oldalakról szóló információkat.

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

Az utolsó oldal nem található

NextPage

Navigáljon a DjVu dokumentumon keresztül a következő oldalhoz hozzáférve ezzelkényelmes ingatlan. gyorsan halad előre a dokumentum megtekintésében vagyfeldolgozási feladatokat.

public DjvuPage NextPage { get; }

ingatlan értéke

DjvuPage

Exceptions

DjvuImageException

A következő oldal nem található

PageCount

Visszaállítsa a DjVu képgyűjteményének összes oldalát ezzel a tulajdonsággal.Ideális a DjVu formátumban tárolt dokumentum vagy könyv nagyságának gyors értékelésére.Javítsa a munkafolyamat hatékonyságát a pontos oldalszámítási információkkal.

public override int PageCount { get; }

ingatlan értéke

int

Pages

Hozzáférés a DjVu képgyűjteményének egyedi oldalaihoz ezzel a tulajdonsággal.Egyszerűsítse a DjVu formátumban tárolt dokumentum vagy könyv navigációját és manipulálásátaz egyes oldalakhoz való hozzáférés közvetlenül. javítsa a munkafolyamat hatékonyságát könnyenOldal visszavonulása.

public override Image[] Pages { get; }

ingatlan értéke

Image []

Examples

Ez a példa azt mutatja, hogyan kell feltölteni egy DJVU képet egy fájl áramlásától.

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

Gyorsan forduljon vissza a DjVu dokumentum megtekintése vagy feldolgozása feladatokhozzáférés a korábbi oldalon ezzel a kényelmes tulajdonsággal. hatékonyan navigáljonA dokumentumok segítségével könnyedén.

public DjvuPage PreviousPage { get; }

ingatlan értéke

DjvuPage

Exceptions

DjvuImageException

Az előző oldal nem található

Methods

AdjustBrightness(int)

A brightness" egy kép egy meghatározott paraméterrel történő beállítása,az optimális vizuális világosság érdekében a fényszint ellenőrzését biztosítja.Ez a módszer javító csökkenti a kép teljes fényességét, lehetővé téve a finom beállítások elérését a kívánt világítási hatásokhoz.A fény modulálásával a felhasználók optimalizálhatják az elképzelhetőséget és javíthatják a részletes reprodukciót a jobb megtekintési élmény érdekében.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

A fény értéke.

Examples

A következő példa egy DJVU kép fényességének korrekcióját végzi.

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

Javítja Aspose.Imaging.A kép kontrasztja a vizuális világosság javításához éshangsúlyozza a részleteket ezzel a módszerrel, amely igazítja a fénykülönbséget afényes és sötét területek. A finom tónusú kontrasztszintek révén a felhasználók élénkebb éshatásos képek, javítja az általános képminőséget és maximalizálja a részlet láthatóségét.Ez a beállítás segíti a finom árnyalatok megjelenítését a színben és a textúrában, amiDinamikusabb és vizuálisan vonzóbb képek.

public override void AdjustContrast(float contrast)

Parameters

contrast float

A kontraszt értéke (tartományban [-100; 100])

Examples

A következő példa egy DJVU kép kontrasztjavítását végzi.

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

Gamma korrekció, különösen a vörös, zöld és kék csatornák, magában foglalja a módosításaz egyes színkomponensek fényessége külön. különböző gamma alkalmazásávalKoefficiensek az RGB csatornák, akkor finomítsa az általános fényerő és kontrasztEz a technika biztosítja a pontos színrepresentációt és javítja azA kép vizuális minősége a különböző kijelzőeszközökön keresztül.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma a vörös, zöld és kék csatornák koefficiens

Examples

A következő példa egy DJVU kép gamma-javítását végzi.

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(hajó, hajó, hajó)

A gamma korrekciót egy ábrára alkalmazzák, amely a piros, zöld paraméterekkel rendelkezik,és kék csatornák, lehetővé téve a szín egyensúlyának és fényességének pontos kiigazítását.a módszer javítja a képminőséget finom tónusú színes képalkotással, biztosítva az optimálisRendering különböző kijelzőeszközökön keresztül. A gamma értékek egyéni beállításaA csatornák javítják a színek egyensúlyát és a vizuális vonzerejét.

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

Parameters

gammaRed float

Gamma a vörös csatorna koefficienshez

gammaGreen float

Gamma a zöld csatorna koefficienshez

gammaBlue float

Gamma a kék csatorna koefficienshez

Examples

A következő példa egy DJVU kép gamma-javítását végzi, amely különböző koefficienseket alkalmaz a színkomponensekhez.

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(kettős, int)

Binarizáció Bradley adaptív határtávolság algoritmusa integrált képekkelA küszöbérték egy olyan módszer, amely az egyes pixelekre vonatkozóan egy helyi határérték kiszámítását jelenti.helyi szomszédság. alkalmazkodik a változások a világítás az egész képet, ígyegyenlőtlen világítási körülményekkel rendelkező képekhez alkalmas. a küszöb kiszámításávalintegrált képeket, hatékonyan kezeli a nagy szomszédságokat, így alkalmazhatóValós idejű alkalmazások. ez a technika gyakran használják a dokumentumfeldolgozás, OCR(Optical Character Recognition) és képszegmentációs feladatok, ahol pontosA binárisítés a későbbi elemzéshez elengedhetetlen.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

A pixel és a s x s ablak közötti fénykülönbségEzzel a pixelrel összpontosítunk.

windowSize int

A s x s ablak mérete a pixel körül összpontosított

Examples

A következő példa bináris egy DJVU képet Bradley adaptív határidős algoritmussal a meghatározott ablak méretével.

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

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

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

BinarizeFixed(Byte)

Binarizáció egy előre meghatározott küszöbvel egyszerűsíti a komplex képeket a binárisképek, ahol a pixeleket fekete vagy fehérként osztályozzák, aaz intenzitás egy meghatározott küszöbértékhez képest.Ezt a technikát gyakran használjákképfeldolgozás a világosság növelése, az elemzés egyszerűsítése és a képek további előkészítése érdekébenfeldolgozási lépések, mint például az optikai karakterfelismerés (OCR).határa, gyorsan átalakíthatja a grayscale képeket bináris formába, ígyKönnyebb értelmezni és kivonni az értelmes információkat.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Ha egy pixel megfelelő szürke értéke meghaladja a határértéket, a255 lesz odaítélve, 0 másként.

Examples

A következő példa binarizálja a DJVU képet az előre meghatározott küszöbvelővel. bináris képek csak 2 színt tartalmaznak - fekete és fehér.

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

A Binarizáció az Otsu határtartalom használatával egy olyan technika, amely automatikusan kiszámítja aoptimális küszöbérték a kép histográfiáján alapul.előtér és háttér az intra-osztály változás minimalizálásával. Otsu módszerszéles körben használják a képek osztályozására bináris formában, különösen akkor, ha a terjesztésa pixel intenzitás kétmodális vagy multimodális. ez a megközelítés előnyös a feladatokmint például a tárgy felismerése, a kép szegmentálása és a funkciók kivonása, ahol a pontosságAz előtér és a háttér közötti elválasztás kulcsfontosságú.

public override void BinarizeOtsu()

Examples

A következő példa bináris egy DJVU képet Otsu határtartalommal. Binarizált képek csak 2 színt tartalmaznak - fekete és fehér.

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

Az adatok titkosítása a teljesítmény optimalizálása és a megismétlődő adatok szükségességének csökkentése érdekébenkülső forrásokból való visszavonás.Ez a megközelítés hozzájárul az erőforrások megőrzéséhez,Különösen olyan forgatókönyvekben, ahol az adatokhoz való hozzáférés gyakori vagy az erőforrások korlátozottak.

public override void CacheData()

Examples

Az alábbi példa azt mutatja, hogyan kell titkosítani egy DJVU kép minden oldalát.

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” küldi a képet, hogy összpontosítson bizonyos részletekre vagy távolítsa el a nemkívánatos elemeket,javítja összetételét és vizuális hatását. függetlenül attól, hogy a fényképeket a szociálismédia, weboldal bannerek létrehozása, vagy nyomtatott anyagok tervezése, ez az eszköz segítTökéletesítse a képeket pontossággal és tisztasággal.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

A rektangulát.

Examples

A következő példa egy DJVU képet termesz. A termesztési területet a Aspose.Imaging.Rectangle segítségével határozzák meg.

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 és int)

A növény változásokkal lehetővé teszi, hogy pontosan igazítsa a pozíciót és a dimenziókat aa kép belsejében felhalmozódott terület. Ez a funkció értéktelen a finomító kompozíciókhoz,összhangban az elemek, és hangsúlyozza a fókuszpontok a vizuális.a vágási folyamat, akkor elérheti a pixel-tökéletes pontosság és finom tónusA képeket könnyedén rögzítjük.

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

Parameters

leftShift int

A baloldali változás.

rightShift int

A helyes változás.

topShift int

A legfelső változás.

bottomShift int

Az alsó változás.

Dither(DitheringMethod, int, IColorPalette)

A “Dither” funkció hatással van a képre, javítva a vizuális hatásátminőség a kötés csökkentésével és a színátalakítás javításával.digitális művészet, fotográfia vagy grafikai tervezési projektek, ez a funkció hozzáadja aprofesszionális érintkezés a képek, így úgy néz ki, sima és finomabb.

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

Parameters

ditheringMethod DitheringMethod

Az eltávolító módszer.

bitsCount int

Az utolsó bitek számolnak a ditheringre.

customPalette IColorPalette

A Dithering számára használt paletták.

Examples

A következő példa feltölti a DJVU képet, és különböző palettás mélységgel végzi a küszöböt és az áramlást.

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

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

                                                                                                                                 // Perform threshold dithering using 4-bit color palette which contains 16 colors.
                                                                                                                                 // The more bits specified the higher quality and the bigger size of the output image.
                                                                                                                                 // Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
                                                                                                                                 dicomImage.Dither(Aspose.Imaging.DitheringMethod.ThresholdDithering, 4, null);

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

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

                                                                                                                                 // Perform floyd dithering using 1-bit color palette which contains only 2 colors - black and white.
                                                                                                                                 // The more bits specified the higher quality and the bigger size of the output image.
                                                                                                                                 // Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
                                                                                                                                 dicomImage.Dither(Aspose.Imaging.DitheringMethod.FloydSteinbergDithering, 1, null);

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

Filter(Rectangle, FilterOptionsBázis)

Alkalmazza a szűrőket egy meghatározott rektanguláris területen a képben, hogy javítsa vagy módosítja aa megjelenés. a konkrét régiók célzásával ez a módszer lehetővé teszi a pontos kiigazításokat,Például a művészi hatások, mint például a blurring, sharpening, vagy alkalmazása, hogy elérje a kívánt vizuálisA kiválasztott területeken a finom hangszóró szűrők lehetővé teszik a felhasználók számára, hogy személyre szabják a képetaz esztétika, javítja a világosságot, és létrehozza a művészi hatások illeszkedik a preferenciák.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

A rektangulát.

options FilterOptionsBase

Az opciók.

Examples

A következő példa alkalmazza a különböző típusú szűrők egy DJVU kép.

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

A Grayscale átalakítása egy képet fekete-fehér képké alakítja, aholMindegyik pixel intenzitását egyetlen értéke képviseli, amely fekete-fehérre változik.Ez a folyamat eltávolítja a színes információt, ami egy monochromatikus képet eredményez.A képeket gyakran használják olyan alkalmazásokban, ahol a szín nem szükséges, vagy ahol az egyszerűségelőnyben részesül, mint például a dokumentumok szkennelése, nyomtatása és bizonyos típusú képelemzés.

public override void Grayscale()

Examples

A következő példa átalakítja a színes DJVU képet a szürke színű képképre. a Grayscale képek kizárólag szörnyű árnyalatokból állnak, és csak intenzitási információkat hordoznak.

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)

Töltse le a DjVu dokumentumot ezzel a módszerrel. Streamline a folyamatot gyorsanhozzáférni és importálni a DjVu fájlokat az alkalmazás.

public static DjvuImage LoadDocument(Stream stream)

Parameters

stream Stream

Az áramlás.

Returns

DjvuImage

DVD dokumentumok

LoadDocument(Áramlat, LoadOptions)

Importálja a DjVu dokumentumot ezzel a módszerrel az áramlással és a terhelésselOpciókA folyamat áramlása a DjVu fájlok gyors hozzáférésével és importálásávalaz Ön alkalmazásába, rugalmas és testreszabási lehetőségeket biztosítva, hogy megfeleljenAz Ön igénye.

public static DjvuImage LoadDocument(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

Az áramlás.

loadOptions LoadOptions

A terhelési lehetőségek.

Returns

DjvuImage

DVD dokumentumok

ReleaseManagedResources()

A kezelt erőforrások kibocsátása. Győződjön meg róla, hogy itt nem bocsátják ki a kezeletlen forrásokat, mivel azok lehetnekMár szabadon bocsátották.

protected override void ReleaseManagedResources()

Resize(Az int, int, resizeType)

Visszaállítsa a képet a Resize módszer, amely egyszerű és hatékony módona képek méreteinek az Ön igényeinek megfelelően történő kiigazítása.A sokoldalú funkcionalitás lehetővé teszi, hogy könnyen méretezzen képeket a kívánt méretre,A felhasználhatóság javítása a különböző platformokon és alkalmazásokon keresztül.

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

Parameters

newWidth int

Az új szélesség.

newHeight int

Az új magasság.

resizeType ResizeType

A visszavágó típus.

Examples

Ez a példa feltölti a DJVU képet, és különböző reszizációs módszerekkel újrahasznosítja.

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

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

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

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

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

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

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

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

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

Resize(int, int, ImageResizeSettings)

Visszaállítsa a képet a kijelölt szélességhez és magassághoz, miközben további beállításokat alkalmazEz a módszer lehetővé teszi a felhasználók számára, hogy módosítsák a kép dimenzióit, miközbenA kívánt tulajdonságok fenntartása, mint például a aspektus arány, a képminőség és a tömörítésA rugalmasság biztosítása révén a visszahívási opciók, a felhasználók alkalmazhatják a képetmegfelel a konkrét követelményeknek, és optimalizálja megjelenését a különböző alkalmazásokhoz ésA platformok

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

Parameters

newWidth int

Az új szélesség.

newHeight int

Az új magasság.

settings ImageResizeSettings

A helyreállítási beállítások.

Examples

Ez a példa feltölti a DJVU képet, és a különböző újratelepítési beállítások segítségével újrahasznosítja.

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(Részletesebben ResizeType)

The ResizeHeightProportionally A módszer lehetővé teszi, hogy módosítsa a magasságát akép, miközben megőrzi annak aspektus arányát. Ez biztosítja, hogy a kép fenntartjaarányai, megakadályozzák a torzítást és megőrizzék vizuális integritását.Függetlenül attól, hogy optimalizálja a képeket weboldalakra, mobilalkalmazásokra vagy nyomtatott médiára, eza módszer biztosítja, hogy a képek néz ki a legjobb a különböző platformok és eszközök.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

Az új magasság.

resizeType ResizeType

A visszahúzódás típusa.

Examples

Ez a példa egy DJVU képet tölti fel, és arányosan átirányítja a különböző visszahívási módszerek használatával. Csak a magasságot jelzik, a szélességet automatikusan kiszámítják.

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(Részletesebben ResizeType)

The ResizeWidthProportionally A módszer egy kényelmes megoldást kínál aa kép szélessége, miközben megtartja annak aspektus arányát.a szélesség, biztosíthatja, hogy a képek maradnak vizuálisan vonzó éskövetkezetes a különböző eszközökön és a képernyőméretekben, javítva sokoldalúságukatHasználhatóság különböző kontextusokban.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

Az új szélesség.

resizeType ResizeType

A visszahúzódás típusa.

Examples

Ez a példa egy DJVU képet tölti fel, és arányosan átirányítja a különböző visszahívási módszerek használatával. Csak a szélességet határozzák meg, a magasságot automatikusan kiszámítják.

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

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

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

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

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

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

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

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

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

Rotate(Float, Bool, Szín)

A képet a középpont körül a Rotate módszerrel forgatja.RasterCachedMultipageImage osztály. Ez a kényelmes funkció lehetővé teszi, hogy könnyena képek orientációjának beállítása, miközben központi pozíciójuk megtartása,javítja kép manipulációs képességeit.

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

Parameters

angle float

A fordulati szög fokban. pozitív értékek fordulnak órásan.

resizeProportionally bool

ha a ‘igaz’ beállítva megváltozik a kép méretét a forgatott rektangul (szögpontok) projekciókkal összhangban, más esetekben, amelyek a dimenziókat érintetlenül hagyják, és csak belső kép tartalmát forgatták.

backgroundColor Color

A háttér színe.

RotateFlip(RotateFlipType)

The RotateFlip módszer kínál sokoldalú manipulációs lehetőségeket a kép, lehetővé téveakkor forgatni, flip, vagy végre mindkét művelet az aktív keret függetlenül.Akár fotók szerkesztése, grafika létrehozása, vagy a digitális művészet javítása, eza módszer pontos ellenőrzést biztosít a képek irányításáról és összetételéről,Győződjön meg róla, hogy könnyedén és hatékonyan teljesítik kreatív látásukat.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

A rotatott flip típus.

Examples

Ez a példa egy DJVU képet tölti fel, 90 fokos órásan forgatja, és opcionálisan horizontáltan és/vagy függőlegesen csúszik.

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)

Megtakarítja az adatokat.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Az áram, hogy mentse az adatokat.

UpdateDimensions(Az int, int)

A kép dimenzióinak frissítése.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Az új kép szélessége.

newHeight int

Az új kép magassága.

PropertyChanged

Ez akkor történik, amikor az ingatlan értéke megváltozik.

public event PropertyChangedEventHandler PropertyChanged

esemény típusa

PropertyChangedEventHandler

 Magyar