Class PngOptions

Class PngOptions

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

Vytvorte vysoko kvalitné Portable Network Graphics (PNG) raster obrázky bez námahys našou API, ktorá ponúka prispôsobiteľné možnosti pre úrovne kompresie,bits na hĺbky pixelov, a alfa bitov. bezproblémovo spracovať XMP metadata kontajnery,zabezpečenie komplexného manažmentu metaúdajov obrazu a umožnenie prispôsobenia saPNG obrázky na vaše presné špecifikácie s ľahkosťou.

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

Inheritance

object DisposableObject ImageOptionsBase PngOptions

Derived

ApngOptions

Implements

IDisposable , IHasXmpData , IHasMetadata , ICloneable

Z dedičných členov

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

Tento príklad ukazuje použitie rôznych tried z SaveOptions Namespace na exportné účely. obrázok typu Gif sa nahráva do príkladu Obrázok a potom sa vyváža do viacerých formátov.

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));
                                                                                                                                                                                                                    }

Nasledujúci príklad ukazuje, ako previesť viacstránkový vektorový obrázok do formátu PNG vo všeobecnosti bez odkazu na konkrétny typ obrazu.

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);
                                                                                                                                                           }

Tento príklad používa triedu Graphics na vytvorenie primitívnych tvarov na povrchu obrazu. Na preukázanie operácie, vzor vytvára nový obrázok vo formáte PNG a natáča primitívne tvary na obrazovej ploche pomocou metód natáčania vystavených triedy Graffics

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

Initalizuje novú inštanciu triedy Aspose.Imaging.ImageOptions.PngOption.

public PngOptions()

PngOptions(PngOptions)

Initalizuje novú inštanciu triedy Aspose.Imaging.ImageOptions.PngOption.

public PngOptions(PngOptions pngOptions)

Parameters

pngOptions PngOptions

Možnosti PNG.

Fields

DefaultCompressionLevel

Predvolená úroveň kompresie.

public const int DefaultCompressionLevel = 6

Fieldová hodnota

int

Properties

BitDepth

Získa alebo nastaví hodnoty bitovej hĺbky v rozmedzí 1, 2, 4, 8, 16.

Zvážte nasledujúce limity:

Aspose.Imaging.FileFormats.Png.Type.IndexedColor podporuje bitovú hĺbku 1, 2, 4, 8.

Aspose.Imaging.FileFormats.Png.pngColorType.Grayscale, Wl17.Doklady formátov.PG. PngColortýpky.grayScalWithAlpha podporuje bitovú hĺbku 8.

Aspose.Imaging.FileFormats.Png.pngColorType.Truecolor, Wl17.DataFormatov. Png ColorStyp.truecoulorVithAlpha podporuje bitovú hĺbku 8, 16.

public byte BitDepth { get; set; }

Hodnota nehnuteľnosti

byte

Examples

Tento príklad ukazuje, ako vytvoriť obrázok PNG s uvedenými možnosťami, vyplniť ho lineárnou gradientovou farbou a uložiť ho do súboru.

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");
                                                                                                                                                }

Nasledujúci príklad ukazuje, ako uložiť obrázok do formátu PNG pomocou rôznych možností.

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

Získať alebo nastaviť typ farby.

public PngColorType ColorType { get; set; }

Hodnota nehnuteľnosti

PngColorType

Examples

Nasledujúci príklad ukazuje, ako komprimovať obrázok PNG pomocou indexovanej farby s najlepšou paletou

// 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

Tento príklad ukazuje, ako vytvoriť obrázok PNG s uvedenými možnosťami, vyplniť ho lineárnou gradientovou farbou a uložiť ho do súboru.

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");
                                                                                                                                                }

Nasledujúci príklad ukazuje, ako uložiť obrázok do formátu PNG pomocou rôznych možností.

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

Získajte alebo nastavíte úroveň kompresie Aspose.Imaging.FileFormats.Png.pngImage v rozmedzí 0-9.Čím vyššia je hodnota - tým efektívnejšie je komisia.

public int CompressionLevel { get; set; }

Hodnota nehnuteľnosti

int

Examples

Nasledujúci príklad ukazuje, ako komprimovať obrázok PNG pomocou indexovanej farby s najlepšou paletou

// 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

Tento príklad ukazuje, ako vytvoriť obrázok PNG s uvedenými možnosťami, vyplniť ho lineárnou gradientovou farbou a uložiť ho do súboru.

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");
                                                                                                                                                }

Nasledujúci príklad ukazuje, ako uložiť obrázok do formátu PNG pomocou rôznych možností.

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

Získať alebo nastaviť typ filtra používaný počas procesu uložiť súbor png.

public PngFilterType FilterType { get; set; }

Hodnota nehnuteľnosti

PngFilterType

Examples

Tento príklad ukazuje, ako vytvoriť obrázok PNG s uvedenými možnosťami, vyplniť ho lineárnou gradientovou farbou a uložiť ho do súboru.

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");
                                                                                                                                                }

Nasledujúci príklad ukazuje, ako rôzne typy filtra ovplyvňujú veľkosť výstupného obrazu PNG.

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.

Nasledujúci príklad ukazuje, ako uložiť obrázok do formátu PNG pomocou rôznych možností.

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

Získava alebo nastaví hodnotu, ktorá naznačuje, či je Aspose.Imaging.FileFormats.Png. PngImage progresívny.

public bool Progressive { get; set; }

Hodnota nehnuteľnosti

bool

Examples

Nasledujúci príklad ukazuje, ako komprimovať obrázok PNG pomocou indexovanej farby s najlepšou paletou

// 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

Tento príklad ukazuje, ako vytvoriť obrázok PNG s uvedenými možnosťami, vyplniť ho lineárnou gradientovou farbou a uložiť ho do súboru.

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");
                                                                                                                                                }

Nasledujúci príklad ukazuje, ako uložiť obrázok do formátu PNG pomocou rôznych možností.

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);
                                                                                                }
 Slovenčina