Image.Save

Save()

Enregistre les données d’image dans le flux sous-jacent.

public void Save()

Voir également

class Image
espace de noms Aspose.PSD
Assemblée Aspose.PSD

Save(string, ImageOptionsBase)

Enregistre les données de l’objet à l’emplacement de fichier spécifié dans le format de fichier spécifié en fonction des options d’enregistrement.

public virtual void Save(string filePath, ImageOptionsBase options)

Paramètre	Taper	La description
filePath	String	Le chemin du fichier.
options	ImageOptionsBase	Les options.

Exemples

L’exemple suivant montre comment vous pouvez exporter des fichiers Adobe Illustrator au format PDF dans Aspose.PSD

[C#]

string sourceFilePath = "rect2_color.ai";
string outputFilePath = "rect2_color.ai_output.pdf";
using (AiImage image = (AiImage)Image.Load(sourceFilePath))
{
    image.Save(outputFilePath, new PdfOptions());
}

L’exemple suivant montre qu’AsposePSD prend en charge l’exportation des fichiers PSB au format PSD.

[C#]

// Prise en charge de l'enregistrement de PSB au format PDF
string sourceFileName = "sample.psb";
string outFileName = "sample.pdf";

using (PsdImage image = (PsdImage)Image.Load(sourceFileName))
{
    image.Save(outFileName, new PdfOptions());
}

Le code suivant enregistre PsdImage en tant que document PDF avec du texte sélectionnable.

[C#]

// L'enregistrement de PSD en PDF ne fournit pas de texte sélectionnable
string sourceFileName = "text.psd";
string outFileName = "text.pdf";

using (PsdImage image = (PsdImage)Image.Load(sourceFileName))
{
    image.Save(outFileName, new PdfOptions());
}

L’exemple suivant montre comment vous pouvez exporter un fichier AI au format PSD et PNG dans Aspose.PSD

[C#]

string sourceFileName = "form_8.ai";
string outputFileName = "form_8_export";
using (AiImage image = (AiImage)Image.Load(sourceFileName))
{
    image.Save(outputFileName + ".psd", new PsdOptions());
    image.Save(outputFileName + ".png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
}

L’exemple suivant montre que l’alignement du texte via ITextPortion pour les langues s’écrivant de droite à gauche fonctionne correctement.

[C#]

string sourceFilePath = "bidi.psd";
string exportFilePath = "bidiOutput.psd";

using (PsdImage image = (PsdImage)Image.Load(sourceFilePath))
{
    TextLayer layer = (TextLayer)image.Layers[2];
    ITextPortion[] portions = layer.TextData.Items;

    portions[0].Paragraph.Justification = JustificationMode.Center;
    layer.TextData.UpdateLayerData();

    image.Save(exportFilePath);
}

Cet exemple montre les étapes simples pour enregistrer une image. Pour illustrer cette opération, nous chargeons un fichier existant à partir d’un emplacement de disque, effectuons une opération de rotation sur l’image et enregistrons l’image au format de fichier Jpeg en utilisant le chemin du fichier

[C#]

//Créer une instance de la classe d'image et l'initialiser avec un fichier existant via le chemin du fichier
using (Aspose.PSD.Image image = Aspose.PSD.Image.Load(@"C:\temp\image.psd"))
{
    //Faire pivoter l'image à 180 degrés autour de l'axe X
    image.RotateFlip(Aspose.PSD.RotateFlipType.Rotate180FlipX);

    // Enregistrer l'image au format Jpeg dans le chemin du fichier avec les paramètres JpegOptions par défaut
    image.Save(@"C:\temp\output.jpeg", new Aspose.PSD.ImageOptions.JpegOptions());
}

L’exemple suivant montre comment vous pouvez modifier la visibilité de LayerGroup dans Aspose.PSD

[C#]

string sourceFilePath = "input.psd";
string outputFilePath = "output.psd";

// apportez des modifications aux noms de couches et enregistrez-les
using (var image = (PsdImage)Image.Load(sourceFilePath))
{
    for (int i = 0; i < image.Layers.Length; i++)
    {
        var layer = image.Layers[i];

        // Désactive tout à l'intérieur d'un groupe
        if (layer is LayerGroup)
        {
            layer.IsVisible = false;
        }
    }

    image.Save(outputFilePath);
}

L’exemple suivant montre comment vous pouvez dessiner sur un calque nouvellement créé si la version du constructeur simple est utilisée dans Aspose.PSD

[C#]

string outputFilePath = "output.psd";

int width = 100;
int height = 100;
using (var image = new PsdImage(width, height))
{
    var layer = new Layer();
    layer.Bottom = height;
    layer.Right = width;
    image.AddLayer(layer);

    Graphics graphic = new Graphics(layer);
    graphic.Clear(Color.Yellow);

    // dessine un rectangle avec l'outil Plume
    graphic.DrawRectangle(new Pen(Color.Red), new Rectangle(30, 10, 40, 80));

    // dessine un autre rectangle avec Solid Brush de couleur bleue
    graphic.DrawRectangle(new Pen(new SolidBrush(Color.Blue)), new Rectangle(10, 30, 80, 40));

    image.Save(outputFilePath);
}

L’exemple suivant montre que la lecture et l’enregistrement des fichiers PSD 16 bits en niveaux de gris en RVB 16 bits par canal fonctionnent correctement et sans exception.

[C#]

string sourceFilePath = "grayscale5x5.psd";
string exportFilePath = "rgb16bit5x5.psd";
PsdOptions psdOptions = new PsdOptions()
{
    ColorMode = ColorModes.Rgb,
    ChannelBitsCount = 16,
    ChannelsCount = 4
};

using (PsdImage image = (PsdImage)Image.Load(sourceFilePath))
{
    RasterCachedImage raster = image.Layers[0];
    Aspose.PSD.Graphics graphics = new Graphics(raster);
    int width = raster.Width;
    int height = raster.Height;
    Rectangle rect = new Rectangle(width / 3, height / 3, width - (2 * (width / 3)) - 1, height - (2 * (height / 3)) - 1);
    graphics.DrawRectangle(new Aspose.PSD.Pen(Color.DarkGray, 1), rect);
    image.Save(exportFilePath, psdOptions);
}

string pngExportPath = Path.ChangeExtension(exportFilePath, "png");
using (PsdImage image = (PsdImage)Image.Load(exportFilePath))
{
    // Ici, il ne devrait pas y avoir d'exception.
    image.Save(pngExportPath, new PngOptions() { ColorType = PngColorType.GrayscaleWithAlpha });
}

L’exemple suivant montre que la lecture et l’enregistrement des fichiers PSD 16 bits en niveaux de gris en niveaux de gris 8 bits par canal fonctionnent correctement et sans exception.

[C#]

string sourceFilePath = "grayscale16bit.psd";
string exportFilePath = "grayscale16bit_Grayscale8_2_RLE.psd";
PsdOptions psdOptions = new PsdOptions()
{
    ColorMode = ColorModes.Grayscale,
    ChannelBitsCount = 8,
    ChannelsCount = 2
};

using (PsdImage image = (PsdImage)Image.Load(sourceFilePath))
{
    RasterCachedImage raster = image.Layers[0];
    Aspose.PSD.Graphics graphics = new Graphics(raster);
    int width = raster.Width;
    int height = raster.Height;
    Rectangle rect = new Rectangle(width / 3, height / 3, width - (2 * (width / 3)) - 1, height - (2 * (height / 3)) - 1);
    graphics.DrawRectangle(new Aspose.PSD.Pen(Color.DarkGray, 1), rect);
    image.Save(exportFilePath, psdOptions);
}

string pngExportPath = Path.ChangeExtension(exportFilePath, "png");
using (PsdImage image = (PsdImage)Image.Load(exportFilePath))
{
    // Ici, il ne devrait pas y avoir d'exception.
    image.Save(pngExportPath, new PngOptions() { ColorType = PngColorType.GrayscaleWithAlpha });
}

L’exemple suivant montre comment vous pouvez utiliser le mode de fusion de calque PassThrough dans Aspose.PSD

[C#]

string sourceFileName = "Apple.psd";
string outputFileName = "OutputApple";
using (PsdImage image = (PsdImage)Image.Load(sourceFileName))
{
    if (image.Layers.Length < 23)
    {
        throw new Exception("There is not 23rd layer.");
    }

    var layer = image.Layers[23] as LayerGroup;

    if (layer == null)
    {
        throw new Exception("The 23rd layer is not a layer group.");
    }

    if (layer.Name != "AdjustmentGroup")
    {
        throw new Exception("The 23rd layer name is not 'AdjustmentGroup'.");
    }

    if (layer.BlendModeKey != BlendMode.PassThrough)
    {
        throw new Exception("AdjustmentGroup layer should have 'pass through' blend mode.");
    }

    image.Save(outputFileName + ".psd", new PsdOptions(image));
    image.Save(outputFileName + ".png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });

    layer.BlendModeKey = BlendMode.Normal;

    image.Save(outputFileName + "Normal.psd", new PsdOptions(image));
    image.Save(outputFileName + "Normal.png", new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
}

L’exemple suivant montre que la progression de la conversion du document fonctionne correctement et sans exception.

[C#]

string sourceFilePath = "Apple.psd";
Stream outputStream = new MemoryStream();

Aspose.PSD.ProgressEventHandler localProgressEventHandler = delegate(ProgressEventHandlerInfo progressInfo)
{
    string message = string.Format(
        "{0} {1}: {2} out of {3}",
        progressInfo.Description,
        progressInfo.EventType,
        progressInfo.Value,
        progressInfo.MaxValue);
    Console.WriteLine(message);
};

Console.WriteLine("---------- Loading Apple.psd ----------");
var loadOptions = new PsdLoadOptions() { ProgressEventHandler = localProgressEventHandler };
using (PsdImage image = (PsdImage)Image.Load(sourceFilePath, loadOptions))
{
    Console.WriteLine("---------- Saving Apple.psd to PNG format ----------");
    image.Save(
        outputStream,
        new PngOptions()
            {
                ColorType = PngColorType.Truecolor,
                ProgressEventHandler = localProgressEventHandler
            });

    Console.WriteLine("---------- Saving Apple.psd to PSD format ----------");
    image.Save(
        outputStream,
        new PsdOptions()
            {
                ColorMode = ColorModes.Rgb,
                ChannelsCount = 4,
                ProgressEventHandler = localProgressEventHandler
            });
}

L’exemple suivant montre que la lecture et l’enregistrement des fichiers PSD 16 bits en niveaux de gris fonctionnent correctement et sans exception.

[C#]

Stack<string> outputFilePathStack = new Stack<string>();

void SaveToPsdThenLoadAndSaveToPng(
    string file,
    ColorModes colorMode,
    short channelBitsCount,
    short channelsCount,
    CompressionMethod compression,
    int layerNumber)
{
    string filePath = file + ".psd";
    string postfix = colorMode.ToString() + channelBitsCount + "_" + channelsCount + "_" + compression;
    string exportPath = file + postfix + ".psd";
    PsdOptions psdOptions = new PsdOptions()
    {
        ColorMode = colorMode,
        ChannelBitsCount = channelBitsCount,
        ChannelsCount = channelsCount,
        CompressionMethod = compression
    };

    using (PsdImage image = (PsdImage)Image.Load(filePath))
    {
        RasterCachedImage raster = layerNumber >= 0 ? (RasterCachedImage)image.Layers[layerNumber] : image;

        Aspose.PSD.Graphics graphics = new Graphics(raster);
        int width = raster.Width;
        int height = raster.Height;
        Rectangle rect = new Rectangle(
            width / 3,
            height / 3,
            width - (2 * (width / 3)) - 1,
            height - (2 * (height / 3)) - 1);
        graphics.DrawRectangle(new Aspose.PSD.Pen(Color.DarkGray, 1), rect);

        image.Save(exportPath, psdOptions);
    }

    string pngExportPath = Path.ChangeExtension(exportPath, "png");
    using (PsdImage image = (PsdImage)Image.Load(exportPath))
    {
        // Ici, il ne devrait pas y avoir d'exception.
        image.Save(pngExportPath, new PngOptions() { ColorType = PngColorType.GrayscaleWithAlpha });
    }

    outputFilePathStack.Push(exportPath);
}

SaveToPsdThenLoadAndSaveToPng("grayscale5x5", ColorModes.Cmyk, 16, 5, CompressionMethod.RLE, 0);
SaveToPsdThenLoadAndSaveToPng("argb16bit_5x5", ColorModes.Grayscale, 16, 2, CompressionMethod.RLE, 0);
SaveToPsdThenLoadAndSaveToPng("argb16bit_5x5_no_layers", ColorModes.Grayscale, 16, 2, CompressionMethod.RLE, -1);
SaveToPsdThenLoadAndSaveToPng("argb8bit_5x5", ColorModes.Grayscale, 16, 2, CompressionMethod.RLE, 0);
SaveToPsdThenLoadAndSaveToPng("argb8bit_5x5_no_layers", ColorModes.Grayscale, 16, 2, CompressionMethod.RLE, -1);
SaveToPsdThenLoadAndSaveToPng("cmyk16bit_5x5_no_layers", ColorModes.Grayscale, 16, 2, CompressionMethod.RLE, -1);
SaveToPsdThenLoadAndSaveToPng("index8bit_5x5", ColorModes.Grayscale, 16, 2, CompressionMethod.RLE, -1);

Voir également

class ImageOptionsBase
class Image
espace de noms Aspose.PSD
Assemblée Aspose.PSD

Save(string, ImageOptionsBase, Rectangle)

Enregistre les données de l’objet à l’emplacement de fichier spécifié dans le format de fichier spécifié en fonction des options d’enregistrement.

public virtual void Save(string filePath, ImageOptionsBase options, Rectangle boundsRectangle)

Paramètre	Taper	La description
filePath	String	Le chemin du fichier.
options	ImageOptionsBase	Les options.
boundsRectangle	Rectangle	L’image de destination délimite le rectangle. Définissez le rectangle vide pour utiliser les limites de la source.

Exceptions

exception	condition
ArgumentNullException	options
ImageSaveException	L’enregistrement de l’image a échoué.

Voir également

class ImageOptionsBase
struct Rectangle
class Image
espace de noms Aspose.PSD
Assemblée Aspose.PSD

Save(Stream, ImageOptionsBase)

Enregistre les données de l’image dans le flux spécifié dans le format de fichier spécifié en fonction des options d’enregistrement.

public void Save(Stream stream, ImageOptionsBase optionsBase)

Paramètre	Taper	La description
stream	Stream	Le flux dans lequel enregistrer les données de l’image.
optionsBase	ImageOptionsBase	Les options de sauvegarde.

Exceptions

exception	condition
ArgumentNullException	optionsBase
ArgumentException	Impossible d’enregistrer au format spécifié car il n’est pas pris en charge pour le moment.;optionsBase
ImageSaveException	L’exportation de l’image a échoué.

Exemples

Cet exemple montre le processus d’enregistrement d’une image dans MemoryStream. Pour illustrer cette opération, l’exemple charge un fichier existant à partir d’un emplacement de disque, effectue une opération de rotation sur l’image et enregistre l’image au format Gif

[C#]

//Créer une instance de MemoryStream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
    //Créer une instance de la classe d'image et l'initialiser avec un fichier existant via le chemin du fichier
    using (Aspose.PSD.Image image = Aspose.PSD.Image.Load(@"C:\temp\image.psd"))
    {
        //Faire pivoter l'image à 180 degrés autour de l'axe X
        image.RotateFlip(Aspose.PSD.RotateFlipType.Rotate180FlipX);

        // Enregistrez l'image au format PSD dans MemoryStream avec les paramètres GifOptions par défaut
        image.Save(stream, new Aspose.PSD.ImageOptions.GifOptions());
    }
}

Voir également

class ImageOptionsBase
class Image
espace de noms Aspose.PSD
Assemblée Aspose.PSD

Save(Stream, ImageOptionsBase, Rectangle)

Enregistre les données de l’image dans le flux spécifié dans le format de fichier spécifié en fonction des options d’enregistrement.

public virtual void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)

Paramètre	Taper	La description
stream	Stream	Le flux dans lequel enregistrer les données de l’image.
optionsBase	ImageOptionsBase	Les options de sauvegarde.
boundsRectangle	Rectangle	L’image de destination délimite le rectangle. Définissez le rectangle vide pour utiliser les limites de la source.

Exceptions

exception	condition
ArgumentNullException	optionsBase
ArgumentException	Impossible d’enregistrer au format spécifié car il n’est pas pris en charge pour le moment.;optionsBase
ImageSaveException	L’exportation de l’image a échoué.

Voir également

class ImageOptionsBase
struct Rectangle
class Image
espace de noms Aspose.PSD
Assemblée Aspose.PSD

Image.RotateFlip Image.SetPalette