Class PsdOptions

Class PsdOptions

Nazwa przestrzeń: Aspose.Imaging.ImageOptions Zgromadzenie: Aspose.Imaging.dll (25.4.0)

Tworzenie zdjęć programu Photoshop Document (PSD) za pomocą naszej API, oferując wszechstronne opcjez różnymi wersjami formatów, metodami kompresji, trybami kolorów ibity liczą na kanał kolorowy. bezprzewodowo obsługuje kontenery metadanych XMP,zapewnienie kompleksowego przetwarzania obrazu z mocą funkcji formatów PSDtakie jak warstwy obrazu, maski warstw i informacje o plikach do dostosowaniaKreatywność w Twoich projektach.

[JsonObject(MemberSerialization.OptIn)]
public class PsdOptions : ImageOptionsBase, IDisposable, IHasXmpData, IHasMetadata, ICloneable

Inheritance

object DisposableObject ImageOptionsBase PsdOptions

Implements

IDisposable , IHasXmpData , IHasMetadata , ICloneable

Dziedziczeni członkowie

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

Ten przykład pokazuje wykorzystanie Aspsoe.Imaging dla .Net API do konwertowania obrazów do formatu PSD. Aby osiągnąć ten cel, ten przykład pobiera istniejący obraz, a następnie przechowuje go z powrotem do formatów PSD

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

                                                                                                                                                                                                            //Creates an instance of image class and initialize it with an existing file through File path
                                                                                                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                                                                                            {
                                                                                                                                                                                                                //Create an instance of PsdOptions class
                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PsdOptions psdOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

                                                                                                                                                                                                                //Set the CompressionMethod as RLE
                                                                                                                                                                                                                //Note: Other supported CompressionMethod is CompressionMethod.RAW [No Compression]
                                                                                                                                                                                                                psdOptions.CompressionMethod = Aspose.Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                                                                                                                                //Set the ColorMode to GrayScale
                                                                                                                                                                                                                //Note: Other supported ColorModes are ColorModes.Bitmap and ColorModes.RGB
                                                                                                                                                                                                                psdOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Grayscale;

                                                                                                                                                                                                                //Save the image to disk location with supplied PsdOptions settings
                                                                                                                                                                                                                image.Save(dir + "output.psd", psdOptions);
                                                                                                                                                                                                            }

Poniższy przykład pokazuje, jak konwertować obraz wektorów wielokierunkowych do formatu PSD w sposób ogólny bez odniesienia do konkretnego typu 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.psd");

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

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

                                                                                                                                                               // Export only first two pages. These pages will be presented as layers in the output PSD.
                                                                                                                                                               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);
                                                                                                                                                           }

Constructors

PsdOptions()

Inicjalizuje nową instancję klasy Aspose.Imaging.ImageOptions.PsdOption.

[JsonConstructor]
public PsdOptions()

PsdOptions(PsdOptions)

Inicjalizuje nową instancję klasy Aspose.Imaging.ImageOptions.PsdOption.

public PsdOptions(PsdOptions options)

Parameters

options PsdOptions

i opcji .

Properties

ChannelBitsCount

Otrzymuje lub ustawia liczenie bitów na kolorowy kanał.

public short ChannelBitsCount { get; set; }

Wartość nieruchomości

short

Examples

Ten przykład pokazuje, jak zaoszczędzić obraz PNG do formatu PSD za pomocą różnych opcji specyficznych dla PSD.

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

                                                                                                       // Create a PNG image of 100x100 px.
                                                                                                       using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100, Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha))
                                                                                                       {
                                                                                                           // Define a linear blue-transparent gradient.
                                                                                                           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 PNG image with the linear blue-transparent gradient.
                                                                                                           graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                           // The following options will be used to save the PNG image to PSD format.
                                                                                                           Aspose.Imaging.ImageOptions.PsdOptions saveOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

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

                                                                                                           // The number of channels. One channel for each color component R,G,B,A
                                                                                                           saveOptions.ChannelsCount = 4;

                                                                                                           // The color mode
                                                                                                           saveOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Rgb;

                                                                                                           // No compression
                                                                                                           saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.Raw;

                                                                                                           // Default version is 6
                                                                                                           saveOptions.Version = 6;            

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.psd"))
                                                                                                           {
                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RAW compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.RLE.psd"))
                                                                                                           {
                                                                                                               // The RLE compression allows to reduce the size of the output image
                                                                                                               saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RLE compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           // The output may look like this:
                                                                                                           // The size of the PSD image with RAW compression: 40090
                                                                                                           // The size of the PSD image with RLE compression: 16185
                                                                                                       }

ChannelsCount

Otrzymuje lub ustawia liczenie kanałów kolorów.

public short ChannelsCount { get; set; }

Wartość nieruchomości

short

Examples

Ten przykład pokazuje, jak zaoszczędzić obraz PNG do formatu PSD za pomocą różnych opcji specyficznych dla PSD.

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

                                                                                                       // Create a PNG image of 100x100 px.
                                                                                                       using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100, Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha))
                                                                                                       {
                                                                                                           // Define a linear blue-transparent gradient.
                                                                                                           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 PNG image with the linear blue-transparent gradient.
                                                                                                           graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                           // The following options will be used to save the PNG image to PSD format.
                                                                                                           Aspose.Imaging.ImageOptions.PsdOptions saveOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

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

                                                                                                           // The number of channels. One channel for each color component R,G,B,A
                                                                                                           saveOptions.ChannelsCount = 4;

                                                                                                           // The color mode
                                                                                                           saveOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Rgb;

                                                                                                           // No compression
                                                                                                           saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.Raw;

                                                                                                           // Default version is 6
                                                                                                           saveOptions.Version = 6;            

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.psd"))
                                                                                                           {
                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RAW compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.RLE.psd"))
                                                                                                           {
                                                                                                               // The RLE compression allows to reduce the size of the output image
                                                                                                               saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RLE compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           // The output may look like this:
                                                                                                           // The size of the PSD image with RAW compression: 40090
                                                                                                           // The size of the PSD image with RLE compression: 16185
                                                                                                       }

ColorMode

Pobierz lub ustawić tryb kolorów PSD.

public ColorModes ColorMode { get; set; }

Wartość nieruchomości

ColorModes

Examples

Ten przykład pokazuje wykorzystanie Aspsoe.Imaging dla .Net API do konwertowania obrazów do formatu PSD. Aby osiągnąć ten cel, ten przykład pobiera istniejący obraz, a następnie przechowuje go z powrotem do formatów PSD

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

                                                                                                                                                                                                            //Creates an instance of image class and initialize it with an existing file through File path
                                                                                                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                                                                                            {
                                                                                                                                                                                                                //Create an instance of PsdOptions class
                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PsdOptions psdOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

                                                                                                                                                                                                                //Set the CompressionMethod as RLE
                                                                                                                                                                                                                //Note: Other supported CompressionMethod is CompressionMethod.RAW [No Compression]
                                                                                                                                                                                                                psdOptions.CompressionMethod = Aspose.Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                                                                                                                                //Set the ColorMode to GrayScale
                                                                                                                                                                                                                //Note: Other supported ColorModes are ColorModes.Bitmap and ColorModes.RGB
                                                                                                                                                                                                                psdOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Grayscale;

                                                                                                                                                                                                                //Save the image to disk location with supplied PsdOptions settings
                                                                                                                                                                                                                image.Save(dir + "output.psd", psdOptions);
                                                                                                                                                                                                            }

Ten przykład pokazuje, jak zaoszczędzić obraz PNG do formatu PSD za pomocą różnych opcji specyficznych dla PSD.

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

                                                                                                       // Create a PNG image of 100x100 px.
                                                                                                       using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100, Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha))
                                                                                                       {
                                                                                                           // Define a linear blue-transparent gradient.
                                                                                                           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 PNG image with the linear blue-transparent gradient.
                                                                                                           graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                           // The following options will be used to save the PNG image to PSD format.
                                                                                                           Aspose.Imaging.ImageOptions.PsdOptions saveOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

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

                                                                                                           // The number of channels. One channel for each color component R,G,B,A
                                                                                                           saveOptions.ChannelsCount = 4;

                                                                                                           // The color mode
                                                                                                           saveOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Rgb;

                                                                                                           // No compression
                                                                                                           saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.Raw;

                                                                                                           // Default version is 6
                                                                                                           saveOptions.Version = 6;            

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.psd"))
                                                                                                           {
                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RAW compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.RLE.psd"))
                                                                                                           {
                                                                                                               // The RLE compression allows to reduce the size of the output image
                                                                                                               saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RLE compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           // The output may look like this:
                                                                                                           // The size of the PSD image with RAW compression: 40090
                                                                                                           // The size of the PSD image with RLE compression: 16185
                                                                                                       }

CompressionMethod

Dostęp lub ustawienie metody kompresji PSD.

public CompressionMethod CompressionMethod { get; set; }

Wartość nieruchomości

CompressionMethod

Examples

Ten przykład pokazuje wykorzystanie Aspsoe.Imaging dla .Net API do konwertowania obrazów do formatu PSD. Aby osiągnąć ten cel, ten przykład pobiera istniejący obraz, a następnie przechowuje go z powrotem do formatów PSD

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

                                                                                                                                                                                                            //Creates an instance of image class and initialize it with an existing file through File path
                                                                                                                                                                                                            using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                                                                                                                            {
                                                                                                                                                                                                                //Create an instance of PsdOptions class
                                                                                                                                                                                                                Aspose.Imaging.ImageOptions.PsdOptions psdOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

                                                                                                                                                                                                                //Set the CompressionMethod as RLE
                                                                                                                                                                                                                //Note: Other supported CompressionMethod is CompressionMethod.RAW [No Compression]
                                                                                                                                                                                                                psdOptions.CompressionMethod = Aspose.Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                                                                                                                                //Set the ColorMode to GrayScale
                                                                                                                                                                                                                //Note: Other supported ColorModes are ColorModes.Bitmap and ColorModes.RGB
                                                                                                                                                                                                                psdOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Grayscale;

                                                                                                                                                                                                                //Save the image to disk location with supplied PsdOptions settings
                                                                                                                                                                                                                image.Save(dir + "output.psd", psdOptions);
                                                                                                                                                                                                            }

Ten przykład pokazuje, jak zaoszczędzić obraz PNG do formatu PSD za pomocą różnych opcji specyficznych dla PSD.

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

                                                                                                       // Create a PNG image of 100x100 px.
                                                                                                       using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100, Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha))
                                                                                                       {
                                                                                                           // Define a linear blue-transparent gradient.
                                                                                                           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 PNG image with the linear blue-transparent gradient.
                                                                                                           graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                           // The following options will be used to save the PNG image to PSD format.
                                                                                                           Aspose.Imaging.ImageOptions.PsdOptions saveOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

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

                                                                                                           // The number of channels. One channel for each color component R,G,B,A
                                                                                                           saveOptions.ChannelsCount = 4;

                                                                                                           // The color mode
                                                                                                           saveOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Rgb;

                                                                                                           // No compression
                                                                                                           saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.Raw;

                                                                                                           // Default version is 6
                                                                                                           saveOptions.Version = 6;            

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.psd"))
                                                                                                           {
                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RAW compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.RLE.psd"))
                                                                                                           {
                                                                                                               // The RLE compression allows to reduce the size of the output image
                                                                                                               saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RLE compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           // The output may look like this:
                                                                                                           // The size of the PSD image with RAW compression: 40090
                                                                                                           // The size of the PSD image with RLE compression: 16185
                                                                                                       }

PsdVersion

Pobierz lub ustawić wersję formatu pliku. może to być PSD lub PSB.

public PsdVersion PsdVersion { get; set; }

Wartość nieruchomości

PsdVersion

RefreshImagePreviewData

Otrzymuje lub ustawia wartość wskazującą, czy [odśwież dane przeglądania obrazu] - opcja wykorzystywana do maksymalizacji zgodności z innymi widzami obrazu PSD.Należy pamiętać, że warstwy tekstowe do ostatniego układu nie są obsługiwane dla platformy Compact Framework.

public bool RefreshImagePreviewData { get; set; }

Wartość nieruchomości

bool

RemoveGlobalTextEngineResource

Otrzymuje lub ustawia wartość wskazującą, czy - Usunąć globalny zasób silnika tekstowego - Używany dla niektórych plików psd z warstwami tekstowymi, tylko w przypadku, gdy nie można ich otworzyć w Adobe Photoshop po przetwarzaniu (głównie dla braku czcionek warstw tekstowych powiązanych).Po użyciu tej opcji, użytkownik musi zrobić następny w otwartym w pliku Photoshop: Menu “Text” -> “Proces nie ma czcionek”.Należy pamiętać, że ta operacja może spowodować pewne ostateczne zmiany w układzie.

public bool RemoveGlobalTextEngineResource { get; set; }

Wartość nieruchomości

bool

VectorizationOptions

Dostęp lub ustaw opcje wektoryzacji PSD.

public PsdVectorizationOptions VectorizationOptions { get; set; }

Wartość nieruchomości

PsdVectorizationOptions

Version

Pobierz lub ustawić wersję pliku PSD.

public int Version { get; set; }

Wartość nieruchomości

int

Examples

Ten przykład pokazuje, jak zaoszczędzić obraz PNG do formatu PSD za pomocą różnych opcji specyficznych dla PSD.

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

                                                                                                       // Create a PNG image of 100x100 px.
                                                                                                       using (Aspose.Imaging.FileFormats.Png.PngImage pngImage = new Aspose.Imaging.FileFormats.Png.PngImage(100, 100, Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha))
                                                                                                       {
                                                                                                           // Define a linear blue-transparent gradient.
                                                                                                           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 PNG image with the linear blue-transparent gradient.
                                                                                                           graphics.FillRectangle(gradientBrush, pngImage.Bounds);

                                                                                                           // The following options will be used to save the PNG image to PSD format.
                                                                                                           Aspose.Imaging.ImageOptions.PsdOptions saveOptions = new Aspose.Imaging.ImageOptions.PsdOptions();

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

                                                                                                           // The number of channels. One channel for each color component R,G,B,A
                                                                                                           saveOptions.ChannelsCount = 4;

                                                                                                           // The color mode
                                                                                                           saveOptions.ColorMode = Aspose.Imaging.FileFormats.Psd.ColorModes.Rgb;

                                                                                                           // No compression
                                                                                                           saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.Raw;

                                                                                                           // Default version is 6
                                                                                                           saveOptions.Version = 6;            

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.psd"))
                                                                                                           {
                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RAW compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           using (System.IO.FileStream stream = System.IO.File.Create(dir + "saveoptions.RLE.psd"))
                                                                                                           {
                                                                                                               // The RLE compression allows to reduce the size of the output image
                                                                                                               saveOptions.CompressionMethod = Imaging.FileFormats.Psd.CompressionMethod.RLE;

                                                                                                               pngImage.Save(stream, saveOptions);
                                                                                                               System.Console.WriteLine("The size of the PSD image with RLE compression: {0}", stream.Length);
                                                                                                           }

                                                                                                           // The output may look like this:
                                                                                                           // The size of the PSD image with RAW compression: 40090
                                                                                                           // The size of the PSD image with RLE compression: 16185
                                                                                                       }

XmpData

Pobierz lub ustawić kontener danych XMP

public override XmpPacketWrapper XmpData { get; set; }

Wartość nieruchomości

XmpPacketWrapper

 Polski