Creación, Apertura y Guardado de Imágenes

Creación de Archivos de Imagen

Aspose.PSD para .NET permite a los desarrolladores crear sus propias imágenes. Utilice el método estático Create expuesto por la clase Image para crear nuevas imágenes. Todo lo que necesita hacer es proporcionar el objeto apropiado de una de las clases del espacio de nombres ImageOptions para el formato de imagen de salida deseado. Para crear un archivo de imagen, primero cree una instancia de una de las clases del espacio de nombres ImageOptions. Estas clases determinan el formato de imagen de salida. A continuación se muestran algunas clases del espacio de nombres ImageOptions (tenga en cuenta que actualmente solo se admiten formatos de archivo PSD):

PsdOptions configura las opciones para crear un archivo PSD. Los archivos de imagen se pueden crear estableciendo una ruta de salida o configurando un flujo.

Creación mediante Configuración de Ruta

Cree PsdOptions desde el espacio de nombres ImageOptions y configure las diferentes propiedades. La propiedad más importante para establecer es la propiedad Source. Esta propiedad especifica dónde residen los datos de la imagen (en un archivo o un flujo). En el siguiente ejemplo, la fuente es un archivo. Después de configurar las propiedades, pase el objeto a uno de los métodos estáticos Create junto con los parámetros de ancho y alto. El ancho y alto están definidos en píxeles.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET


// Creates an instance of PsdOptions and set its various properties
PsdOptions psdOptions = new PsdOptions();
psdOptions.CompressionMethod = CompressionMethod.RLE;

// Define the source property for the instance of PsdOptions. Second boolean parameter determines if the file is temporal or not
psdOptions.Source = new FileCreateSource(desName, false);

// Creates an instance of Image and call Create method by passing the PsdOptions object
using (Image image = Image.Create(psdOptions, 500, 500))
{
    image.Save();
}

Creación Usando un Flujo

El proceso para crear una imagen utilizando un flujo es el mismo que al usar una ruta. La única diferencia es que necesita crear una instancia de StreamSource pasando un objeto Stream a su constructor y asignándolo a la propiedad Source.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string desName = dataDir + "CreatingImageUsingStream_out.bmp";
// Creates an instance of BmpOptions and set its various properties
BmpOptions ImageOptions = new BmpOptions();
ImageOptions.BitsPerPixel = 24;

// Create an instance of System.IO.Stream
Stream stream = new FileStream(dataDir + "sample_out.bmp", FileMode.Create);

// Define the source property for the instance of BmpOptions Second boolean parameter determines if the Stream is disposed once get out of scope
ImageOptions.Source = new StreamSource(stream, true);

// Creates an instance of Image and call Create method by passing the BmpOptions object
using (Image image = Image.Create(ImageOptions, 500, 500))
{
    // Do some image processing
    image.Save(desName);
}

Apertura de Archivos de Imagen

Los desarrolladores pueden utilizar la API de Aspose.PSD para .NET para abrir archivos de imagen PSD existentes para diferentes propósitos, como agregar efectos a la imagen o convertir un archivo existente a otro formato. Sea cual sea el propósito, Aspose.PSD proporciona dos formas estándar de abrir archivos existentes: desde un archivo o desde un flujo.

Apertura desde Disco

Abra un archivo de imagen pasando la ruta y el nombre del archivo como parámetro al método estático Load expuesto por la clase Image.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + "result.png";

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(sourceFile))
{
    PsdImage psdImage = (PsdImage)image;
    psdImage.Save(destName, new PngOptions());
}

Apertura usando un Flujo

A veces, la imagen que necesitamos abrir se almacena como un flujo. En esos casos, utilice la versión sobrecargada del método Load. Este acepta un objeto Stream como argumento para abrir la imagen.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + "result.png";

FileStream fStream = new FileStream(sourceFile, FileMode.Open);
fStream.Position = 0;

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(fStream))
{
    PsdImage psdImage = (PsdImage)image;
    MemoryStream stream = new MemoryStream();
    psdImage.Save(stream, new PngOptions());
}

Cargar Imagen como Capa

Este artículo demuestra el uso de Aspose.PSD para cargar una imagen como capa. Aspose.PSD ha expuesto métodos eficientes y fáciles de usar para lograr este objetivo. Aspose.PSD ha expuesto el método AddLayer de la clase PsdImage para agregar una imagen a un archivo PSD como capa.

Los pasos para cargar una imagen en PSD como capa son tan simples como los siguientes:

• Cree una instancia de una imagen usando la clase PsdImage con un ancho y alto específicos.
• Cargue un archivo PSD como una imagen utilizando el método de fábrica Load expuesto por la clase Image.
• Cree una instancia de la clase Layer y asígnele la capa de imagen PSD.
• Agregue la capa creada utilizando el método AddLayer expuesto por la clase PsdImage.
• Guarde los resultados.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string filePath = dataDir + "PsdExample.psd";
string outputFilePath = dataDir + "PsdResult.psd";
using (var image = new PsdImage(200, 200))
{
    using (var im = Image.Load(filePath))
    {
        Layer layer = null;
        try
        {
            layer = new Layer((RasterImage)im);
            image.AddLayer(layer);
        }
        catch (Exception e)
        {
            if (layer != null)
            {
                layer.Dispose();
            }
            throw;
        }
    }
    image.Save(outputFilePath);
}

Cargar Imagen como Capa desde un Flujo

Este artículo demuestra el uso de Aspose.PSD para cargar una imagen como capa desde un flujo. Para cargar una imagen desde un flujo, simplemente pase un objeto Stream que contenga una imagen al constructor de la clase Layer. Agregue la capa creada utilizando el método AddLayer expuesto por la clase PsdImage y guarde los resultados.

Aquí está el código de muestra.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string outputFilePath = dataDir + "PsdResult.psd";

var filesList = new string[]
{
    "PsdExample.psd",
    "BmpExample.bmp",
    "GifExample.gif",
    "Jpeg2000Example.jpf",
    "JpegExample.jpg",
    "PngExample.png",
    "TiffExample.tif",
};
using (var image = new PsdImage(200, 200))
{
    foreach (var fileName in filesList)
    {
        string filePath = dataDir + fileName;
        using (var stream = new FileStream(filePath, FileMode.Open))
        {
            Layer layer = null;
            try
            {
                layer = new Layer(stream);
                image.AddLayer(layer);
            }
            catch (Exception e)
            {
                if (layer != null)
                {
                    layer.Dispose();
                }
                throw e;
            }
        }
    }
    image.Save(outputFilePath);
}

Guardado de Archivos de Imagen

Aspose.PSD le permite crear archivos de imagen desde cero. También proporciona los medios para editar archivos de imagen existentes. Una vez que la imagen ha sido creada o modificada, el archivo suele guardarse en disco. Aspose.PSD le proporciona métodos para guardar imágenes en disco especificando una ruta o utilizando un objeto Stream.

Guardado en Disco

La clase Image representa un objeto de imagen, por lo que esta clase proporciona todas las herramientas necesarias para crear, cargar y guardar un archivo de imagen. Utilice el método Save de la clase Image para guardar imágenes. Una versión sobrecargada del método Save acepta la ubicación del archivo como una cadena.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + "result.png";

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(sourceFile))
{
    PsdImage psdImage = (PsdImage)image;
    psdImage.Save(destName, new PngOptions());
}

Guardado en un Flujo

Otra versión sobrecargada del método Save acepta un objeto Stream como argumento y guarda el archivo de imagen en el flujo.

Si la imagen se crea especificando cualquiera de las CreateOptions en el constructor de Image, la imagen se guardará automáticamente en la ruta o en el flujo suministrado durante la inicialización de la clase Image llamando al método Save que no acepta ningún parámetro.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string sourceFile = dataDir + @"sample.psd";
string destName = dataDir + "result.png";

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(sourceFile))
{
    PsdImage psdImage = (PsdImage)image;
    MemoryStream stream = new MemoryStream();
    psdImage.Save(stream, new PngOptions());
}

Configuración para Reemplazar Fuentes Faltantes

Los desarrolladores pueden utilizar la API de Aspose.PSD para .NET para cargar archivos de imagen PSD existentes para diferentes propósitos, por ejemplo, establecer el nombre de fuente predeterminado al guardar documentos PSD como una imagen de mapa de bits (en formatos PNG, JPG y BMP). Esta fuente predeterminada debe usarse como reemplazo para todas las fuentes faltantes (fuentes que no se encuentran en el sistema operativo actual). Una vez que la imagen ha sido modificada, el archivo se guardará en disco.

// For complete examples and data files, please go to https://github.com/aspose-psd/Aspose.PSD-for-.NET

string sourceFileName = "sample_konstanting.psd";

string[] outputs = new string[]
{
    "replacedfont0.tiff",
    "replacedfont1.png",
    "replacedfont2.jpg"
};

using (PsdImage image = (PsdImage)Image.Load(sourceFileName, new PsdLoadOptions()))
{
    // This way you can use different fonts for different outputs 
    image.Save(outputs[0], new TiffOptions(TiffExpectedFormat.TiffJpegRgb) { DefaultReplacementFont = "Arial" });
    image.Save(outputs[1], new PngOptions { DefaultReplacementFont = "Verdana" });
    image.Save(outputs[2], new JpegOptions { DefaultReplacementFont = "Times New Roman" });
}