Image.Save

Save()

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

public void Save()

Voir également


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ètreTaperLa description
filePathStringLe chemin du fichier.
optionsImageOptionsBaseLes 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


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ètreTaperLa description
filePathStringLe chemin du fichier.
optionsImageOptionsBaseLes options.
boundsRectangleRectangleL’image de destination délimite le rectangle. Définissez le rectangle vide pour utiliser les limites de la source.

Exceptions

exceptioncondition
ArgumentNullExceptionoptions
ImageSaveExceptionL’enregistrement de l’image a échoué.

Voir également


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ètreTaperLa description
streamStreamLe flux dans lequel enregistrer les données de l’image.
optionsBaseImageOptionsBaseLes options de sauvegarde.

Exceptions

exceptioncondition
ArgumentNullExceptionoptionsBase
ArgumentExceptionImpossible d’enregistrer au format spécifié car il n’est pas pris en charge pour le moment.;optionsBase
ImageSaveExceptionL’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


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ètreTaperLa description
streamStreamLe flux dans lequel enregistrer les données de l’image.
optionsBaseImageOptionsBaseLes options de sauvegarde.
boundsRectangleRectangleL’image de destination délimite le rectangle. Définissez le rectangle vide pour utiliser les limites de la source.

Exceptions

exceptioncondition
ArgumentNullExceptionoptionsBase
ArgumentExceptionImpossible d’enregistrer au format spécifié car il n’est pas pris en charge pour le moment.;optionsBase
ImageSaveExceptionL’exportation de l’image a échoué.

Voir également