Class PngOptions

Class PngOptions

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

Hozzon létre kiváló minőségű Portable Network Graphics (PNG) raster képeket erőteljesenAPI-nkkel, amely személyre szabható opciókat kínál a tömörítési szintekhez,bits per pixel mélységek, és alfa bitek. szelíd feldolgozása XMP metadata tartályok,átfogó képmetadatok kezelésének biztosítása, valamint az Ön alkalmazkodásának lehetővé tételePNG képek a pontos specifikációkat könnyedén.

public class PngOptions : ImageOptionsBase, IDisposable, IHasXmpData, IHasMetadata, ICloneable

Inheritance

object DisposableObject ImageOptionsBase PngOptions

Derived

ApngOptions

Implements

IDisposable , IHasXmpData , IHasMetadata , ICloneable

Örökletes tagok

ImageOptionsBase.Clone() , ImageOptionsBase.ReleaseManagedResources() , ImageOptionsBase.KeepMetadata , ImageOptionsBase.XmpData , ImageOptionsBase.Source , ImageOptionsBase.Palette , ImageOptionsBase.ResolutionSettings , ImageOptionsBase.VectorRasterizationOptions , ImageOptionsBase.BufferSizeHint , ImageOptionsBase.MultiPageOptions , ImageOptionsBase.FullFrame , ImageOptionsBase.ProgressEventHandler , DisposableObject.Dispose() , DisposableObject.ReleaseManagedResources() , DisposableObject.ReleaseUnmanagedResources() , DisposableObject.VerifyNotDisposed() , DisposableObject.Disposed , object.GetType() , object.MemberwiseClone() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

Ez a példa azt mutatja, hogy a különböző osztályok használata a SaveOptions Namespace export célokra. A Gif típusú képet egy kép példájába töltjük le, majd több formátumra exportáljuk.

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

                                                                                                                                                                                                                    //Load an existing image (of type Gif) in an instance of Image class
                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
                                                                                                                                                                                                                    {
                                                                                                                                                                                                                        //Export to BMP file format using the default options
                                                                                                                                                                                                                        image.Save(dir + "output.bmp", new Aspose.Imaging.ImageOptions.BmpOptions());

                                                                                                                                                                                                                        //Export to JPEG file format using the default options
                                                                                                                                                                                                                        image.Save(dir + "output.jpg", new Aspose.Imaging.ImageOptions.JpegOptions());

                                                                                                                                                                                                                        //Export to PNG file format using the default options
                                                                                                                                                                                                                        image.Save(dir + "output.png", new Aspose.Imaging.ImageOptions.PngOptions());

                                                                                                                                                                                                                        //Export to TIFF file format using the default options
                                                                                                                                                                                                                        image.Save(dir + "output.tif", new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default));
                                                                                                                                                                                                                    }

Az alábbi példa azt mutatja, hogyan lehet egy többoldalú vektorképet általános módon PNG formátumra konvertálni anélkül, hogy egy adott képtípusra utalna.

string dir = "C:\\aspose.imaging\\net\\misc\\ImagingReleaseQATester\\Tests\\testdata\\2548";
                                                                                                                                                           string inputFilePath = System.IO.Path.Combine(dir, "Multipage.cdr");
                                                                                                                                                           string outputFilePath = System.IO.Path.Combine(dir, "Multipage.cdr.png");

                                                                                                                                                           Aspose.Imaging.ImageOptionsBase exportOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                           using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(inputFilePath))
                                                                                                                                                           {
                                                                                                                                                               exportOptions.MultiPageOptions = null;

                                                                                                                                                               // Export only first two pages. In fact, only one page will be rasterized because PNG is not a multi-page format.
                                                                                                                                                               Aspose.Imaging.IMultipageImage multipageImage = image as Aspose.Imaging.IMultipageImage;
                                                                                                                                                               if (multipageImage != null && (multipageImage.Pages != null && multipageImage.PageCount > 2))
                                                                                                                                                               {
                                                                                                                                                                   exportOptions.MultiPageOptions = new Aspose.Imaging.ImageOptions.MultiPageOptions(new Aspose.Imaging.IntRange(0, 2));
                                                                                                                                                               }

                                                                                                                                                               if (image is Aspose.Imaging.VectorImage)
                                                                                                                                                               {
                                                                                                                                                                   exportOptions.VectorRasterizationOptions = (Aspose.Imaging.ImageOptions.VectorRasterizationOptions)image.GetDefaultOptions(new object[] { Aspose.Imaging.Color.White, image.Width, image.Height });
                                                                                                                                                                   exportOptions.VectorRasterizationOptions.TextRenderingHint = Aspose.Imaging.TextRenderingHint.SingleBitPerPixel;
                                                                                                                                                                   exportOptions.VectorRasterizationOptions.SmoothingMode = Aspose.Imaging.SmoothingMode.None;
                                                                                                                                                               }

                                                                                                                                                               image.Save(outputFilePath, exportOptions);
                                                                                                                                                           }

Ez a példa a Graphics-osztályt használja az elsődleges formák létrehozására a kép felszínén.A művelet demonstrálása érdekében a minta egy új PNG formátumú képet hoz létre, és a grafika osztály által kimutatott rajz módszerekkel rajzol primitív formákat.

//Creates an instance of FileStream
                                                                                                                                                                                                                                                                using (System.IO.FileStream stream = new System.IO.FileStream(@"C:\temp\output.png", System.IO.FileMode.Create))
                                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                                    //Create an instance of PngOptions and set its various properties
                                                                                                                                                                                                                                                                    Aspose.Imaging.ImageOptions.PngOptions pngOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                                                                                                                                    //Set the Source for PngOptions
                                                                                                                                                                                                                                                                    pngOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);

                                                                                                                                                                                                                                                                    //Create an instance of Image 
                                                                                                                                                                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(pngOptions, 500, 500))
                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                        //Create and initialize an instance of Graphics class
                                                                                                                                                                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                                                                                                                                                                                        //Clear Graphics surface
                                                                                                                                                                                                                                                                        graphics.Clear(Aspose.Imaging.Color.Wheat);

                                                                                                                                                                                                                                                                        //Draw an Arc by specifying the Pen object having Black color, 
                                                                                                                                                                                                                                                                        //a Rectangle surrounding the Arc, Start Angle and Sweep Angle
                                                                                                                                                                                                                                                                        graphics.DrawArc(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Black, 2), new Aspose.Imaging.Rectangle(200, 200, 100, 200), 0, 300);

                                                                                                                                                                                                                                                                        //Draw a Bezier by specifying the Pen object having Blue color and co-ordinate Points.
                                                                                                                                                                                                                                                                        graphics.DrawBezier(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Blue, 2), new Aspose.Imaging.Point(250, 100), new Aspose.Imaging.Point(300, 30), new Aspose.Imaging.Point(450, 100), new Aspose.Imaging.Point(235, 25));

                                                                                                                                                                                                                                                                        //Draw a Curve by specifying the Pen object having Green color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawCurve(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Green, 2), new[] { new Aspose.Imaging.Point(100, 200), new Aspose.Imaging.Point(100, 350), new Aspose.Imaging.Point(200, 450) });

                                                                                                                                                                                                                                                                        //Draw an Ellipse using the Pen object and a surrounding Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawEllipse(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Yellow, 2), new Aspose.Imaging.Rectangle(300, 300, 100, 100));

                                                                                                                                                                                                                                                                        //Draw a Line 
                                                                                                                                                                                                                                                                        graphics.DrawLine(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Violet, 2), new Aspose.Imaging.Point(100, 100), new Aspose.Imaging.Point(200, 200));

                                                                                                                                                                                                                                                                        //Draw a Pie segment
                                                                                                                                                                                                                                                                        graphics.DrawPie(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Silver, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(200, 20), new Aspose.Imaging.Size(200, 200)), 0, 45);

                                                                                                                                                                                                                                                                        //Draw a Polygon by specifying the Pen object having Red color and an array of Points
                                                                                                                                                                                                                                                                        graphics.DrawPolygon(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Red, 2), new[] { new Aspose.Imaging.Point(20, 100), new Aspose.Imaging.Point(20, 200), new Aspose.Imaging.Point(220, 20) });

                                                                                                                                                                                                                                                                        //Draw a Rectangle
                                                                                                                                                                                                                                                                        graphics.DrawRectangle(new Aspose.Imaging.Pen(Aspose.Imaging.Color.Orange, 2), new Aspose.Imaging.Rectangle(new Aspose.Imaging.Point(250, 250), new Aspose.Imaging.Size(100, 100)));

                                                                                                                                                                                                                                                                        //Create a SolidBrush object and set its various properties
                                                                                                                                                                                                                                                                        Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush();
                                                                                                                                                                                                                                                                        brush.Color = Color.Purple;
                                                                                                                                                                                                                                                                        brush.Opacity = 100;

                                                                                                                                                                                                                                                                        //Draw a String using the SolidBrush object and Font, at specific Point
                                                                                                                                                                                                                                                                        graphics.DrawString("This image is created by Aspose.Imaging API", new Aspose.Imaging.Font("Times New Roman", 16), brush, new Aspose.Imaging.PointF(50, 400));

                                                                                                                                                                                                                                                                        // save all changes.
                                                                                                                                                                                                                                                                        image.Save();
                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                }

Constructors

PngOptions()

Kezdeményez egy új példát a Aspose.Imaging.ImageOptions.Pngoptions osztály.

public PngOptions()

PngOptions(PngOptions)

Kezdeményez egy új példát a Aspose.Imaging.ImageOptions.Pngoptions osztály.

public PngOptions(PngOptions pngOptions)

Parameters

pngOptions PngOptions

A PNG opciók.

Fields

DefaultCompressionLevel

Az alapértelmezett kompressziós szint.

public const int DefaultCompressionLevel = 6

mező értéke

int

Properties

BitDepth

Megkapja vagy beállítja a bit mélység értékeit 1, 2, 4, 8, 16 tartományban.

Emlékezzünk a következő korlátokra:

Aspose.Imaging.FileFormats.Png.Type.IndexedColor támogatja a bit mélység 1, 2, 4, 8.

Aspose.Imaging.FileFormats.Png.pngColorType.Grayscale, Wl17.Diplomaformátumok, Png-PgColorstype, grafikaVithAlpha támogatja a bit mélységét 8.

Aspose.Imaging.FileFormats.Png.pngColorType.Truecolor, Wl17.Diplomaformátumok, Png-pgColortypes.trukoloraVithAlpha támogatja a bit mélységét 8, 16.

public byte BitDepth { get; set; }

ingatlan értéke

byte

Examples

Ez a példa azt mutatja, hogyan kell létrehozni egy PNG képet a megadott opciókkal, kitölteni egy lineáris gradiens színekkel, és menteni egy fájlba.

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

                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                // The number of bits per color channel
                                                                                                                                                createOptions.BitDepth = 8;

                                                                                                                                                // Each pixel is a (red, green, blue) triple followed by the alpha component.
                                                                                                                                                createOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                                                                // The maximum level of compression.
                                                                                                                                                createOptions.CompressionLevel = 9;

                                                                                                                                                // Usage of filters allows to compress continuous tonal images more effectively.
                                                                                                                                                createOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Sub;

                                                                                                                                                // Use progressive loading
                                                                                                                                                createOptions.Progressive = true;

                                                                                                                                                // Create a PNG image with custom parameters.
                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(createOptions, 100, 100))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                                                                    // Fill the image with a semi-transparent gradient.
                                                                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                                                                    // Save to a file.
                                                                                                                                                    pngImage.Save(dir + "output.explicitoptions.png");
                                                                                                                                                }

Az alábbi példa azt mutatja, hogyan lehet menteni egy képet PNG formátumban különböző opciók segítségével.

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

                                                                                                // Create a PNG image of 100x100 px.
                                                                                                // You can also load image of any supported format from a file or a stream.
                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                                {
                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                    // Fill the image with the blue-transparent gradient.
                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                    Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                    // Progressive loading.
                                                                                                    saveOptions.Progressive = true;

                                                                                                    // Set the horizontal and vertical resolution to 96 pixels per inch.
                                                                                                    saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                    // Each pixel is a (red, green, blue) triple followed by alpha.
                                                                                                    saveOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                    // Set the maximum level of compression.
                                                                                                    saveOptions.CompressionLevel = 9;

                                                                                                    // This is the best compression, but the slowest execution time.
                                                                                                    // Adaptive filtering means that saving process will choose most sutable filter for each data row.
                                                                                                    saveOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Adaptive;

                                                                                                    // The number of bits per channel.
                                                                                                    saveOptions.BitDepth = 8;

                                                                                                    // Save to a file.
                                                                                                    pngImage.Save(dir + "output.png", saveOptions);
                                                                                                }

ColorType

Megkapja vagy beállítja a szín típusát.

public PngColorType ColorType { get; set; }

ingatlan értéke

PngColorType

Examples

A következő példa azt mutatja, hogyan kell tömöríteni egy PNG képet, indexelt színt használva a legjobb illeszkedő palettával

// Loads png image        
                                                                                                                 string  sourceFilePath="OriginalRings.png";
                                                                                                                 string  outputFilePath="OriginalRingsOutput.png";
                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(sourceFilePath))
                                                                                                             {
                                                                                                                 image.Save(outputFilePath, new Aspose.Imaging.ImageOptions.PngOptions()
                                                                                                                 {
                                                                                                                      Progressive = true,
                                                                                                                          // Use indexed color type
                                                                                                                      ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                          // Use maximal compression
                                                                                                                      CompressionLevel = 9,
                                                                                                                   // Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
                                                                                                                      // is almost visually indistinguishable from a non-palletized one.
                                                                                                                      Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                                 });
                                                                                                             }
                                                                                                                 // The output file size should be significantly reduced

Ez a példa azt mutatja, hogyan kell létrehozni egy PNG képet a megadott opciókkal, kitölteni egy lineáris gradiens színekkel, és menteni egy fájlba.

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

                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                // The number of bits per color channel
                                                                                                                                                createOptions.BitDepth = 8;

                                                                                                                                                // Each pixel is a (red, green, blue) triple followed by the alpha component.
                                                                                                                                                createOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                                                                // The maximum level of compression.
                                                                                                                                                createOptions.CompressionLevel = 9;

                                                                                                                                                // Usage of filters allows to compress continuous tonal images more effectively.
                                                                                                                                                createOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Sub;

                                                                                                                                                // Use progressive loading
                                                                                                                                                createOptions.Progressive = true;

                                                                                                                                                // Create a PNG image with custom parameters.
                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(createOptions, 100, 100))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                                                                    // Fill the image with a semi-transparent gradient.
                                                                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                                                                    // Save to a file.
                                                                                                                                                    pngImage.Save(dir + "output.explicitoptions.png");
                                                                                                                                                }

Az alábbi példa azt mutatja, hogyan lehet menteni egy képet PNG formátumban különböző opciók segítségével.

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

                                                                                                // Create a PNG image of 100x100 px.
                                                                                                // You can also load image of any supported format from a file or a stream.
                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                                {
                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                    // Fill the image with the blue-transparent gradient.
                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                    Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                    // Progressive loading.
                                                                                                    saveOptions.Progressive = true;

                                                                                                    // Set the horizontal and vertical resolution to 96 pixels per inch.
                                                                                                    saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                    // Each pixel is a (red, green, blue) triple followed by alpha.
                                                                                                    saveOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                    // Set the maximum level of compression.
                                                                                                    saveOptions.CompressionLevel = 9;

                                                                                                    // This is the best compression, but the slowest execution time.
                                                                                                    // Adaptive filtering means that saving process will choose most sutable filter for each data row.
                                                                                                    saveOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Adaptive;

                                                                                                    // The number of bits per channel.
                                                                                                    saveOptions.BitDepth = 8;

                                                                                                    // Save to a file.
                                                                                                    pngImage.Save(dir + "output.png", saveOptions);
                                                                                                }

CompressionLevel

Megkapja vagy beállítja a Aspose.Imaging.FileFormats.Png. PngImage kompressziós szintet a 0-9 tartományban. minél magasabb az érték - annál hatékonyabb a tömörítés.

public int CompressionLevel { get; set; }

ingatlan értéke

int

Examples

A következő példa azt mutatja, hogyan kell tömöríteni egy PNG képet, indexelt színt használva a legjobb illeszkedő palettával

// Loads png image        
                                                                                                                 string  sourceFilePath="OriginalRings.png";
                                                                                                                 string  outputFilePath="OriginalRingsOutput.png";
                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(sourceFilePath))
                                                                                                             {
                                                                                                                 image.Save(outputFilePath, new Aspose.Imaging.ImageOptions.PngOptions()
                                                                                                                 {
                                                                                                                      Progressive = true,
                                                                                                                          // Use indexed color type
                                                                                                                      ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                          // Use maximal compression
                                                                                                                      CompressionLevel = 9,
                                                                                                                   // Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
                                                                                                                      // is almost visually indistinguishable from a non-palletized one.
                                                                                                                      Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                                 });
                                                                                                             }
                                                                                                                 // The output file size should be significantly reduced

Ez a példa azt mutatja, hogyan kell létrehozni egy PNG képet a megadott opciókkal, kitölteni egy lineáris gradiens színekkel, és menteni egy fájlba.

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

                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                // The number of bits per color channel
                                                                                                                                                createOptions.BitDepth = 8;

                                                                                                                                                // Each pixel is a (red, green, blue) triple followed by the alpha component.
                                                                                                                                                createOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                                                                // The maximum level of compression.
                                                                                                                                                createOptions.CompressionLevel = 9;

                                                                                                                                                // Usage of filters allows to compress continuous tonal images more effectively.
                                                                                                                                                createOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Sub;

                                                                                                                                                // Use progressive loading
                                                                                                                                                createOptions.Progressive = true;

                                                                                                                                                // Create a PNG image with custom parameters.
                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(createOptions, 100, 100))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                                                                    // Fill the image with a semi-transparent gradient.
                                                                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                                                                    // Save to a file.
                                                                                                                                                    pngImage.Save(dir + "output.explicitoptions.png");
                                                                                                                                                }

Az alábbi példa azt mutatja, hogyan lehet menteni egy képet PNG formátumban különböző opciók segítségével.

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

                                                                                                // Create a PNG image of 100x100 px.
                                                                                                // You can also load image of any supported format from a file or a stream.
                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                                {
                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                    // Fill the image with the blue-transparent gradient.
                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                    Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                    // Progressive loading.
                                                                                                    saveOptions.Progressive = true;

                                                                                                    // Set the horizontal and vertical resolution to 96 pixels per inch.
                                                                                                    saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                    // Each pixel is a (red, green, blue) triple followed by alpha.
                                                                                                    saveOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                    // Set the maximum level of compression.
                                                                                                    saveOptions.CompressionLevel = 9;

                                                                                                    // This is the best compression, but the slowest execution time.
                                                                                                    // Adaptive filtering means that saving process will choose most sutable filter for each data row.
                                                                                                    saveOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Adaptive;

                                                                                                    // The number of bits per channel.
                                                                                                    saveOptions.BitDepth = 8;

                                                                                                    // Save to a file.
                                                                                                    pngImage.Save(dir + "output.png", saveOptions);
                                                                                                }

FilterType

Megkapja vagy beállítja a png fájl mentési folyamat során használt szűrő típusát.

public PngFilterType FilterType { get; set; }

ingatlan értéke

PngFilterType

Examples

Ez a példa azt mutatja, hogyan kell létrehozni egy PNG képet a megadott opciókkal, kitölteni egy lineáris gradiens színekkel, és menteni egy fájlba.

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

                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                // The number of bits per color channel
                                                                                                                                                createOptions.BitDepth = 8;

                                                                                                                                                // Each pixel is a (red, green, blue) triple followed by the alpha component.
                                                                                                                                                createOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                                                                // The maximum level of compression.
                                                                                                                                                createOptions.CompressionLevel = 9;

                                                                                                                                                // Usage of filters allows to compress continuous tonal images more effectively.
                                                                                                                                                createOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Sub;

                                                                                                                                                // Use progressive loading
                                                                                                                                                createOptions.Progressive = true;

                                                                                                                                                // Create a PNG image with custom parameters.
                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(createOptions, 100, 100))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                                                                    // Fill the image with a semi-transparent gradient.
                                                                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                                                                    // Save to a file.
                                                                                                                                                    pngImage.Save(dir + "output.explicitoptions.png");
                                                                                                                                                }

Az alábbi példa azt mutatja, hogy a különböző szűrőtípusok hogyan befolyásolják a kimeneti PNG kép méretét.

Aspose.Imaging.FileFormats.Png.PngFilterType[] filterTypes = new Aspose.Imaging.FileFormats.Png.PngFilterType[]
                                                                                                          {
                                                                                                              Aspose.Imaging.FileFormats.Png.PngFilterType.None,
                                                                                                              Aspose.Imaging.FileFormats.Png.PngFilterType.Up,
                                                                                                              Aspose.Imaging.FileFormats.Png.PngFilterType.Sub,
                                                                                                              Aspose.Imaging.FileFormats.Png.PngFilterType.Paeth,
                                                                                                              Aspose.Imaging.FileFormats.Png.PngFilterType.Avg,
                                                                                                              Aspose.Imaging.FileFormats.Png.PngFilterType.Adaptive,
                                                                                                          };

                                                                                                          foreach (Aspose.Imaging.FileFormats.Png.PngFilterType filterType in filterTypes)
                                                                                                          {
                                                                                                              Aspose.Imaging.ImageOptions.PngOptions options = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                              using (Aspose.Imaging.Image image = Image.Load("c:\\temp\\sample.png"))
                                                                                                              {
                                                                                                                  // Set a filter type
                                                                                                                  options.FilterType = filterType;

                                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                                  {
                                                                                                                      image.Save(stream, options);
                                                                                                                      System.Console.WriteLine("The filter type is {0}, the output image size is {1} bytes.", filterType, stream.Length);
                                                                                                                  }
                                                                                                              }
                                                                                                          }

                                                                                                          //The output may look like this:
                                                                                                          //The filter type is None, the output image size is 116845 bytes.
                                                                                                          //The filter type is Up, the output image size is 86360 bytes.
                                                                                                          //The filter type is Sub, the output image size is 94907 bytes.
                                                                                                          //The filter type is Paeth, the output image size is 86403 bytes.
                                                                                                          //The filter type is Avg, the output image size is 89956 bytes.
                                                                                                          //The filter type is Adaptive, the output image size is 97248 bytes.

Az alábbi példa azt mutatja, hogyan lehet menteni egy képet PNG formátumban különböző opciók segítségével.

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

                                                                                                // Create a PNG image of 100x100 px.
                                                                                                // You can also load image of any supported format from a file or a stream.
                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                                {
                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                    // Fill the image with the blue-transparent gradient.
                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                    Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                    // Progressive loading.
                                                                                                    saveOptions.Progressive = true;

                                                                                                    // Set the horizontal and vertical resolution to 96 pixels per inch.
                                                                                                    saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                    // Each pixel is a (red, green, blue) triple followed by alpha.
                                                                                                    saveOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                    // Set the maximum level of compression.
                                                                                                    saveOptions.CompressionLevel = 9;

                                                                                                    // This is the best compression, but the slowest execution time.
                                                                                                    // Adaptive filtering means that saving process will choose most sutable filter for each data row.
                                                                                                    saveOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Adaptive;

                                                                                                    // The number of bits per channel.
                                                                                                    saveOptions.BitDepth = 8;

                                                                                                    // Save to a file.
                                                                                                    pngImage.Save(dir + "output.png", saveOptions);
                                                                                                }

Progressive

Megkapja vagy beállítja az értéket, amely azt jelzi, hogy egy Aspose.Imaging.FileFormats.Png. PngImage progresszív.

public bool Progressive { get; set; }

ingatlan értéke

bool

Examples

A következő példa azt mutatja, hogyan kell tömöríteni egy PNG képet, indexelt színt használva a legjobb illeszkedő palettával

// Loads png image        
                                                                                                                 string  sourceFilePath="OriginalRings.png";
                                                                                                                 string  outputFilePath="OriginalRingsOutput.png";
                                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(sourceFilePath))
                                                                                                             {
                                                                                                                 image.Save(outputFilePath, new Aspose.Imaging.ImageOptions.PngOptions()
                                                                                                                 {
                                                                                                                      Progressive = true,
                                                                                                                          // Use indexed color type
                                                                                                                      ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                          // Use maximal compression
                                                                                                                      CompressionLevel = 9,
                                                                                                                   // Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
                                                                                                                      // is almost visually indistinguishable from a non-palletized one.
                                                                                                                      Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                                 });
                                                                                                             }
                                                                                                                 // The output file size should be significantly reduced

Ez a példa azt mutatja, hogyan kell létrehozni egy PNG képet a megadott opciókkal, kitölteni egy lineáris gradiens színekkel, és menteni egy fájlba.

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

                                                                                                                                                Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                                                                // The number of bits per color channel
                                                                                                                                                createOptions.BitDepth = 8;

                                                                                                                                                // Each pixel is a (red, green, blue) triple followed by the alpha component.
                                                                                                                                                createOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                                                                // The maximum level of compression.
                                                                                                                                                createOptions.CompressionLevel = 9;

                                                                                                                                                // Usage of filters allows to compress continuous tonal images more effectively.
                                                                                                                                                createOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Sub;

                                                                                                                                                // Use progressive loading
                                                                                                                                                createOptions.Progressive = true;

                                                                                                                                                // Create a PNG image with custom parameters.
                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(createOptions, 100, 100))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                                                                    // Fill the image with a semi-transparent gradient.
                                                                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                                                                    // Save to a file.
                                                                                                                                                    pngImage.Save(dir + "output.explicitoptions.png");
                                                                                                                                                }

Az alábbi példa azt mutatja, hogyan lehet menteni egy képet PNG formátumban különböző opciók segítségével.

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

                                                                                                // Create a PNG image of 100x100 px.
                                                                                                // You can also load image of any supported format from a file or a stream.
                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100))
                                                                                                {
                                                                                                    Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                            new Aspose.Imaging.Point(pngImage.Width, pngImage.Height),
                                                                                                            Aspose.Imaging.Color.Blue,
                                                                                                            Aspose.Imaging.Color.Transparent);

                                                                                                    Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(pngImage);

                                                                                                    // Fill the image with the blue-transparent gradient.
                                                                                                    graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                    Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();

                                                                                                    // Progressive loading.
                                                                                                    saveOptions.Progressive = true;

                                                                                                    // Set the horizontal and vertical resolution to 96 pixels per inch.
                                                                                                    saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                    // Each pixel is a (red, green, blue) triple followed by alpha.
                                                                                                    saveOptions.ColorType = Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;

                                                                                                    // Set the maximum level of compression.
                                                                                                    saveOptions.CompressionLevel = 9;

                                                                                                    // This is the best compression, but the slowest execution time.
                                                                                                    // Adaptive filtering means that saving process will choose most sutable filter for each data row.
                                                                                                    saveOptions.FilterType = Aspose.Imaging.FileFormats.Png.PngFilterType.Adaptive;

                                                                                                    // The number of bits per channel.
                                                                                                    saveOptions.BitDepth = 8;

                                                                                                    // Save to a file.
                                                                                                    pngImage.Save(dir + "output.png", saveOptions);
                                                                                                }
 Magyar