Class DjvuImage

Class DjvuImage

De naam: Aspose.Imaging.FileFormats.Djvu Verzameling: Aspose.Imaging.dll (25.4.0)

DjVu-documentklasse ondersteunt grafisch bestandformaat en maakt het gemakkelijkhet beheer van gescande documenten en boeken, het integreren van tekst, tekeningen, afbeeldingen,en foto’s in een enkel formaat. ondersteuning van multi-page operaties, kunt uefficiënt toegang tot unieke documentidentificatoren, pagina’s tellen, actieve pagina’s instellen;en herhalen specifieke documentpagina’s. met functies voor resing, roteren,Dithering, grapping, groyscale transformatie, gamma correcties, aanpassingen,en filteren applicatie, deze klasse vergemakkelijkt nauwkeurige manipulatie en verbeteringvan DjVu afbeeldingen om te voldoen aan verschillende toepassingsbehoeften met gemakkelijkheid en nauwkeurigheid.

[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

Geëerbiede leden

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

Dit voorbeeld laat zien hoe je een DJVU-afbeelding uit een bestandstromen kunt laden.

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)

Begin met werken met DjVu-beelden door een nieuwe instantie van deAspose.Imaging.FileFormats.Djvu.JJvuImage klasse met behulp van een Stream parameter.Ontwikkelaars die de integratie van DjVu-beeldverwerking inhun projecten.

public DjvuImage(Stream stream)

Parameters

stream Stream

De stroom.

Examples

Dit voorbeeld laat zien hoe je een DJVU-afbeelding uit een bestandstromen kunt laden.

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

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

Exceptions

DjvuImageException

Stream is leeg

DjvuImage(Stream, LoadOptions)

Begin met het werken met DjVu-afbeeldingen naadloos met deze constructeur, dieinitialiseren van een nieuwe Aspose.Imaging.FileFormats.Djvu.JvImage-klasseinstantie met een Stream enLoadOptions parameters. Perfect voor ontwikkelaars die nauwkeurige controle overDjVu image loading opties terwijl het eenvoud en efficiëntie behouden.

public DjvuImage(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

De stroom om uit te laden.

loadOptions LoadOptions

De lading opties.

Examples

Dit voorbeeld laat zien hoe je een DJVU-afbeelding van een bestandstromen kunt laden om binnen de aangegeven geheugengrenzen te blijven.

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

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

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

Exceptions

DjvuImageException

Stream is leeg

Properties

ActivePage

Navigeren door uw DjVu-document door toegang te krijgen tot of de huidige actievepagina met behulp van deze eigenschap. onvermijdelijk wisselen tussen de pagina’s om zich te richten op specifiekeinhoud en verbeteren van uw documentvisualisatie ervaring.

public DjvuPage ActivePage { get; set; }

Eigendomswaarde

DjvuPage

Examples

Dit voorbeeld toont hoe je een DJVU-afbeelding uit een bestandstromen kunt laden en informatie over de pagina’s kunt afdrukken.

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

Er is geen actieve pagina geselecteerd.

DjvuPages

Snel alle pagina’s in uw DjVu-document terugvinden met behulp van dezevergemakkelijkt uw documentbewerkingswerkstroom door gemakkelijk toegang te krijgen tot enhet beheren van individuele pagina’s binnen uw DjVu-bestanden. verbetering van efficiëntie envergemakkelijkt uw taken met behulp van een comfortabele pagina retrieval.

public DjvuPage[] DjvuPages { get; }

Eigendomswaarde

DjvuPage []

FileFormat

Krijg de bestandformaat informatie geassocieerd met uw DjVu beeldbestand.bepaal het formaat van uw bestand voor onmiddellijke integratie in uw werkstroom.

public override FileFormat FileFormat { get; }

Eigendomswaarde

FileFormat

FirstPage

Ga naar de eerste pagina van uw DjVu-document met deze eigendom.de oorspronkelijke pagina om uw document efficiënt te bekijken of te verwerken.

public DjvuPage FirstPage { get; }

Eigendomswaarde

DjvuPage

Examples

Dit voorbeeld toont hoe je een DJVU-afbeelding uit een bestandstromen kunt laden en informatie over de pagina’s kunt afdrukken.

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

De eerste pagina is niet te vinden

HasAlpha

Snel bepalen of uw DjVu-beeldbestand een alfa-kanaal bevat.Vergemakkelijkt uw werkstroom door te controleren voor de aanwezigheid van transparantie informatiein je afbeeldingen.

public override bool HasAlpha { get; }

Eigendomswaarde

bool

Identifier

Geeft de unieke identificator voor het document

public int Identifier { get; }

Eigendomswaarde

int

LastPage

Verwijder de laatste pagina van uw DjVu-document met behulp van deze eigendom.de laatste pagina voor zicht- of verwerkingsdoeleinden gemakkelijk.

public DjvuPage LastPage { get; }

Eigendomswaarde

DjvuPage

Examples

Dit voorbeeld toont hoe je een DJVU-afbeelding uit een bestandstromen kunt laden en informatie over de pagina’s kunt afdrukken.

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

De laatste pagina is niet te vinden

NextPage

Navigeren door uw DjVu-document door naar de volgende pagina te gaan met ditComfortabele eigendom. snel vooruitgaan in uw document te bekijken ofverwerking van taken.

public DjvuPage NextPage { get; }

Eigendomswaarde

DjvuPage

Exceptions

DjvuImageException

De volgende pagina is niet te vinden

PageCount

Verwijder het totale aantal pagina’s in uw DjVu beeldverzameling met deze eigenschap.Ideaal voor snelle beoordeling van de omvang van uw document of boek opgeslagen in DjVu-formaat.Verbeter de efficiëntie van uw werkstroom met nauwkeurige pagina rekeninformatie.

public override int PageCount { get; }

Eigendomswaarde

int

Pages

Toegang tot de individuele pagina’s van uw DjVu beeldverzameling met deze eigenschap.Eenvoudige navigatie en manipulatie van uw document of boek opgeslagen in DjVudoor elke pagina rechtstreeks te bereiken. verbeter uw werkstroom efficiëntie met gemakkelijkpagina terugvallen.

public override Image[] Pages { get; }

Eigendomswaarde

Image []

Examples

Dit voorbeeld laat zien hoe je een DJVU-afbeelding uit een bestandstromen kunt laden.

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

Snel om terug te gaan in uw DjVu-document met het bekijken of verwerken van taken doortoegang tot de vorige pagina met deze handige eigenschap. efficiënt navigerenMet behulp van uw document gemakkelijk.

public DjvuPage PreviousPage { get; }

Eigendomswaarde

DjvuPage

Exceptions

DjvuImageException

De vorige pagina is niet te vinden

Methods

AdjustBrightness(Int)

Het aanpassen van de briliteit van een afbeelding met een bepaald parameter, het verstrekken van controle over de luminance niveaus voor optimale visuele helderheid. Deze methode verbetert vermindert de algemene glans van het beeld, waardoor fijne aanpassingen voldoen aan de gewenste verlichting effecten. Door het moduleren van lichtheid, kunnen gebruikers de imagevisibiliteit te optimaliseren en de gedetailleerde reproductie te verhogen voor een betere bekijkingservaring.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

De briljante waarde.

Examples

Het volgende voorbeeld uitvoert de helderheidcorrectie van een DJVU-afbeelding.

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

Verbeter Aspose.Imaging.Image contrast om de visuele duidelijkheid te verbeteren enonderstreept de details met deze methode, die het verschil in helderheid tussenlicht en donker gebieden. door de contrastniveaus van fine-tuning, kunnen gebruikers meer levend enimpactvolle afbeeldingen, de algemene beeldkwaliteit verbeteren en de zichtbaarheid van de details te maximaliseren.Deze aanpassing helpt subtiele nuances in kleur en textuur uit te brengen, wat resulteert inmeer dynamische en visueel aantrekkelijke beelden.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Contrastwaarde (in bereik [-100; 100])

Examples

Het volgende voorbeeld uitvoert een contrastcorrectie van een DJVU-afbeelding.

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

Gamma-correctie, met name voor de rode, groene en blauwe kanalen, omvat aanpassingde helderheid van elk kleurcomponent afzonderlijk. door het toepassen van verschillende gammaCoefficiënten voor de RGB-kanalen, kunt u de algemene helderheid en contrast goed tonenDeze techniek zorgt voor een nauwkeurige kleurrepresentatie en verbetert devisuele kwaliteit van het beeld over verschillende displayapparaten.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma voor rode, groene en blauwe kanalen coëfficiënt

Examples

Het volgende voorbeeld uitvoert een gamma-correctie van een DJVU-afbeelding.

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(De vloot, de vloot, de vloot)

Gamma-correctie wordt toegepast op een afbeelding met aanpassbare parameters voor de rode, groene,en blauwe kanalen, waardoor nauwkeurige aanpassing van kleurbalans en helderheid mogelijk is.methode verbetert de beeldkwaliteit door fine-tuning kleurvertegenwoordiging, zorgen voor optimalerendering over verschillende displayapparaten. aanpassen van gamma waarden voor individueleKanalen verbeteren kleurbalans en visuele aantrekkingskracht.

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

Parameters

gammaRed float

Gamma voor de rode kanaal coefficiënt

gammaGreen float

Gamma voor groene kanaal coëfficiënt

gammaBlue float

Gamma voor blauw kanaal coefficiënt

Examples

Het volgende voorbeeld uitvoert een gamma-correctie van een DJVU-afbeelding die verschillende coëfficiënten toepast op kleurcomponenten.

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

Binarisatie met behulp van Bradley’s adaptieve thresholding-algoritme met integrale afbeeldingeen thresholding is een methode die een lokaal drempel voor elk pixel berekent op basis van eenlokale wijk. het aanpast aan variaties in verlichting over het beeld, waardoor hetgeschikt voor afbeeldingen met ongelijke verlichtingsomstandigheden. door de grens te berekenen met behulp vangeïntegreerde afbeeldingen, het efficiënt beheert grote buurlanden, waardoor het van toepassing is opReal-time applicaties. deze techniek wordt vaak gebruikt in documentverwerking, OCR(Optical Character Recognition) en beeldsegmentatie taken waar nauwkeurigBinarisatie is essentieel voor latere analyses.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Het lichtverschil tussen de pixel en het gemiddelde van een s x s venster van pixelsHet gaat om deze pixel.

windowSize int

De grootte van de s x s venster van pixels centraal rond deze pixel

Examples

Het volgende voorbeeld binarisert een DJVU-afbeelding met Bradley’s adaptieve grenzenalgoritme met de aangegeven venstergrootte.

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)

Binarisatie met een vooraf gedefinieerde drempel vereenvoudigt complexe beelden in binairevertegenwoordigingen, waarbij pixels worden gecategoriseerd als zwart of wit op basis van hunintensiteit in vergelijking met een bepaald grenswaarde. deze techniek wordt meestal gebruikt inbeeldverwerking om duidelijkheid te verbeteren, analyse te vereenvoudigen en beelden voor te bereiden voor verderverwerkingsstappen zoals optische karakteridentificatie (OCR). door een vastegrens, kunt u snel grayscale beelden te transformeren in binaire vorm, waardoor zegemakkelijker te interpreteren en betekenisvolle informatie uit te trekken.

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

als de overeenkomstige grijze waarde van een pixel groter is dan de grenswaarde, een255 wordt daartoe toegewezen, 0 anders.

Examples

Het volgende voorbeeld binarisert een DJVU-afbeelding met de vooraf gedefinieerde grens. Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.

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

Binarisatie met behulp van Otsu thresholding is een techniek die automatisch eenoptimale grenswaarde gebaseerd op het histogram van de afbeelding.voorkant en achtergrond door de intra-klasse variatie te minimaliseren.veel gebruikt voor het segmenteren van afbeeldingen in binaire vormen, vooral wanneer de distributievan pixel intensiteiten is bimodal of multimodale. deze benadering is gunstig voor takenzoals objectdetectie, afbeeldingssegmentatie en functieextraction, waar nauwkeurigDe afstemming tussen voorgrond en achtergrond is cruciaal.

public override void BinarizeOtsu()

Examples

Het volgende voorbeeld binarisert een DJVU-afbeelding met Otsu thresholding. Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.

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

De gegevens privé verbergen om de prestaties te optimaliseren en de behoefte aan herhaalde gegevens te verminderenherstel van externe bronnen. deze aanpak helpt ook de middelen te behouden,Vooral in scenario’s waarin de toegang tot gegevens vaak is of de middelen beperkt zijn.

public override void CacheData()

Examples

Het volgende voorbeeld laat zien hoe je alle pagina’s van een DJVU-afbeelding kan verbergen.

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” stuurt uw afbeelding om zich te richten op specifieke details of ongewenste elementen te verwijderen,verbetering van de samenstelling en visuele impact. of u foto’s aanpast voor socialemedia, het maken van website banners, of het ontwerpen van gedrukte materialen, dit gereedschap helpt uVerfijn uw beelden met nauwkeurigheid en duidelijkheid.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

De rechthoek.

Examples

Het volgende voorbeeld groeit een DJVU-afbeelding. het groeiperiode wordt aangegeven via Aspose.Imaging.Rectangle.

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

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

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

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

Crop(int, int, int, int, int)

De plant met schakels stelt u in staat de positie en de afmetingen van degebouwd gebied binnen een afbeelding. deze functie is onwaardever voor verfijnde composities,het aanpassen van elementen, en het benadrukken van focale punten in uw visuals. door het integreren van veranderingenin het grapproces, kunt u bereiken pixel-perfect nauwkeurigheid en fine-tune deOm je afbeeldingen gemakkelijk te maken.

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

Parameters

leftShift int

De linker verandert.

rightShift int

De juiste wisseling.

topShift int

De top shift.

bottomShift int

De bodem verandert.

Dither(DitheringMethod, int, IColorPalette)

De “Dither”-functie toepast een ditheringseffect op uw afbeelding, waardoor het visuele effect wordt verbeterd.kwaliteit door het verminderen van banding en verbetering van kleuroverschrijvingen. of u werktop digitale kunst, fotografie of grafisch ontwerpsprojecten, deze functie voegt eenprofessioneel aanraken op uw beelden, waardoor ze gladder en verfijnlijker lijken.

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

Parameters

ditheringMethod DitheringMethod

De Dithering Methode.

bitsCount int

De laatste bits tellen voor dithering.

customPalette IColorPalette

De gewone palet voor dithering.

Examples

Het volgende voorbeeld loopt een DJVU-afbeelding en uitvoert grenzen en vloeibare dithering met behulp van verschillende paletdichtheid.

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

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

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

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

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

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

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

Filter(Rectangle, FilterOptionsBase)

Voer filters toe aan een bepaald rectangulaire gebied binnen de afbeelding om haar te verbeteren of te wijzigendoor specifieke gebieden te richten, deze methode maakt nauwkeurige aanpassingen mogelijk,zoals bloeien, scherpen of artistieke effecten toepassen, om het gewenste visueel te bereikenFine-tuning filters op geselecteerde gebieden maken gebruikers in staat om de afbeelding aan te passenesthetiek, verbetert duidelijkheid, en creëert artistieke effecten aangepast aan hun voorkeuren.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

De rechthoek.

options FilterOptionsBase

De opties .

Examples

Het volgende voorbeeld geldt voor verschillende soorten filters voor een DJVU-afbeelding.

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

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

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

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

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

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

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

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

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

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

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

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

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

Grayscale()

Grayscale transformatie converteert een afbeelding in een zwarte en witte vertegenwoordiging, waarDe intensiteit van elk pixel wordt vertegenwoordigd door een enkele waarde van zwart tot wit.Dit proces verwijdert kleurinformatie, wat resulteert in een monochromatische afbeelding.beelden worden meestal gebruikt in toepassingen waar kleur onnodig is of waar eenvoudvoorkeur, zoals documentscanning, afdrukken en bepaalde soorten beeldanalyse.

public override void Grayscale()

Examples

Het volgende voorbeeld transformeert een gekleurde DJVU-afbeelding naar zijn grayscale-representatie.Grayescale’s zijn uitsluitend samengesteld uit schaduwen van grijze en dragen alleen intensiteitsinformatie mee.

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)

Load uw DjVu-document met deze methode. Streamline uw proces door sneltoegang tot en het importeren van uw DjVu-bestanden in uw applicatie.

public static DjvuImage LoadDocument(Stream stream)

Parameters

stream Stream

De stroom.

Returns

DjvuImage

Geplaatst in Djvu Document

LoadDocument(Stream, LoadOptions)

Importeer uw DjVu-document door deze methode te gebruiken met stream en loadOptiesStreamline uw proces door snel toegang te krijgen en DjVu-bestanden te importerenin uw applicatie, biedt flexibiliteit en aanpassingsopties om te voldoenUw behoeften .

public static DjvuImage LoadDocument(Stream stream, LoadOptions loadOptions)

Parameters

stream Stream

De stroom.

loadOptions LoadOptions

De lading opties.

Returns

DjvuImage

Geplaatst in Djvu Document

ReleaseManagedResources()

Zorg ervoor dat geen onbeheerde middelen hier worden vrijgegeven, omdat ze mogelijkal vrijgelaten.

protected override void ReleaseManagedResources()

Resize(int, int, resizeType)

De afbeelding herstellen met behulp van de Resize methode, die een eenvoudige en effectieve manier biedtom de afmetingen van uw afbeeldingen aan te passen volgens uw vereisten.versatile functionaliteit stelt u in staat om gemakkelijk afbeeldingen te scalen naar uw gewenste grootte,verbeteren van hun gebruiksbaarheid op verschillende platforms en toepassingen.

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

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

resizeType ResizeType

De resize type.

Examples

Dit voorbeeld loopt een DJVU-afbeelding en resecteert het met behulp van verschillende resisatiemethoden.

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)

Verwijder het beeld naar de aangegeven breedte en hoogte terwijl u aanvullende instellingen toepastDeze methode stelt gebruikers in staat de afmetingen van het beeld aan te passen terwijlhet behouden van gewenste attributen zoals aspect ratio, beeldkwaliteit en compressieDe instellingen. door flexibiliteit te bieden in resizing opties, kunnen gebruikers de afbeelding aanpassen aanvoldoen aan specifieke vereisten en zijn uiterlijk optimaliseren voor verschillende toepassingen enDe platformen.

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

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

settings ImageResizeSettings

De resize instellingen.

Examples

Dit voorbeeld loopt een DJVU-afbeelding en resecteert het met behulp van verschillende resizing-instellingen.

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(Int, ResizeType)

The ResizeHeightProportionally Met de methode kunt u de hoogte van uwbeeld terwijl het aspect ratio behoudt. dit zorgt ervoor dat uw beeldzijn proporties, het voorkomen van vervorming en het behoud van zijn visuele integriteit.Of het nu gaat om het optimaliseren van afbeeldingen voor webpagina’s, mobiele apps of gedrukte media, ditDe methode zorgt ervoor dat uw afbeeldingen het beste uitzien op verschillende platforms en apparaten.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

De nieuwe hoogte.

resizeType ResizeType

Type van de resize.

Examples

Dit voorbeeld loopt een DJVU-afbeelding en resecteert het evenredig met behulp van verschillende resisatiemethoden. Alleen de hoogte wordt aangegeven, de breedte wordt automatisch berekend.

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(Int, ResizeType)

The ResizeWidthProportionally methode biedt een handige oplossing om dede breedte van uw afbeelding terwijl het aspectverhouding behoudt. door proportioneel herziende breedte, kunt u ervoor zorgen dat uw beelden visueel aantrekkelijk blijven enconsistent over verschillende apparaten en schermgrootte, waardoor hun versatiliteit wordt verbeterdGebruikbaarheid in verschillende contexten.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

De nieuwe breedte.

resizeType ResizeType

Type van de resize.

Examples

Dit voorbeeld loopt een DJVU-afbeelding en resecteert het evenredig met behulp van verschillende resisatiemethoden. Alleen de breedte wordt aangegeven, de hoogte wordt automatisch berekend.

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, kleur)

Roteren van het beeld rond het centrum met de Rotate-methode van deRasterCachedMultipageImage klasse. deze handige functie stelt u in staat om gemakkelijk tede oriëntatie van de afbeeldingen aanpassen terwijl ze hun centrale positie behouden,verbeteren van uw beeldmanipulatiecapaciteiten.

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

Parameters

angle float

De rotatie van de hoek in graden. positieve waarden zullen rotatie horloge.

resizeProportionally bool

als je ’true’ hebt ingesteld, zal je afbeeldingsgrootte worden gewijzigd, afhankelijk van rotatie rectangle (kornpunten) projecties in andere gevallen die de dimensies niet aanraken en alleen interne beeldinhoud wordt roterd.

backgroundColor Color

De kleur van de achtergrond.

RotateFlip(RotateFlipType)

The RotateFlip methode biedt veelzijdige manipulatie opties voor uw afbeelding, waardooru om te roteren, flip, of uitvoeren beide operaties op het actieve kader onafhankelijk.Of u nu foto’s bewerkt, grafica creëert of digitale kunst verbetert, ditmethode geeft nauwkeurige controle over de oriëntatie en samenstelling van uw afbeeldingen,Zorg ervoor dat ze uw creatieve visie met gemakkelijkheid en efficiëntie voldoen.

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

De rotated flip type.

Examples

Dit voorbeeld laden een DJVU-afbeelding op, draait het met 90 graden horloge en flipt optioneel het beeld horizontaal en/of verticaal.

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)

Bespaar de gegevens.

protected override void SaveData(Stream stream)

Parameters

stream Stream

De stroom om gegevens op te slaan.

UpdateDimensions(int, int)

Update de afbeeldingsdimensies.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

De nieuwe beeldbreedte.

newHeight int

De nieuwe beeldhoogte.

PropertyChanged

Dit gebeurt wanneer een eigendomswaarde verandert.

public event PropertyChangedEventHandler PropertyChanged

Event type

PropertyChangedEventHandler

 Nederlands