Convertir Imágenes

Convertir Imágenes a Blanco y Negro y en Escala de Grises

A veces puede ser necesario convertir imágenes a color a blanco y negro o en escala de grises para fines de impresión o archivado. Este artículo demuestra el uso de Aspose.PSD para la API de .NET para lograr esto mediante dos métodos como se indica a continuación.

• Binariación
• Escala de grises

Binariación

Para entender el concepto de Binariación, es importante definir una Imagen Binaria; es decir, una imagen digital que solo puede tener dos valores posibles para cada píxel. Normalmente, los dos colores utilizados para una imagen binaria son negro y blanco, aunque se pueden utilizar cualquier par de colores. La binariación es el proceso de convertir una imagen a bi-nivel, lo que significa que cada píxel se almacena como un solo bit (0 o 1), donde 0 denota la ausencia de color y 1 significa presencia de color. Aspose.PSD para la API de .NET actualmente admite dos métodos de binariación.

Binariación con Umbral Fijo

El siguiente fragmento de código le muestra cómo se puede aplicar la binariación con umbral fijo a una 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 + @"BinarizationWithFixedThreshold_out.jpg";

// Load an image
using (Image image = Image.Load(sourceFile))
{
    // Cast the image to RasterCachedImage and Check if image is cached
    RasterCachedImage rasterCachedImage = (RasterCachedImage)image;
    if (!rasterCachedImage.IsCached)
    {
        // Cache image if not already cached
        rasterCachedImage.CacheData();
    }

    // Binarize image with predefined fixed threshold and Save the resultant image
    rasterCachedImage.BinarizeFixed(100);
    rasterCachedImage.Save(destName, new JpegOptions());
}

Binariación con Umbral de Otsu

El siguiente fragmento de código le muestra cómo se puede aplicar la binariación con umbral de Otsu a una 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 + @"BinarizationWithOtsuThreshold_out.jpg";

// Load an image
using (Image image = Image.Load(sourceFile))
{
    // Cast the image to RasterCachedImage and Check if image is cached
    RasterCachedImage rasterCachedImage = (RasterCachedImage)image;
    if (!rasterCachedImage.IsCached)
    {
        // Cache image if not already cached
        rasterCachedImage.CacheData();
    }

    // Binarize image with Otsu Thresholding and Save the resultant image                
    rasterCachedImage.BinarizeOtsu();

    rasterCachedImage.Save(destName, new JpegOptions());
}

Escala de Grises

La escala de grises es el proceso de convertir una imagen de tono continuo a una imagen con tonos de gris discontinuos. El siguiente fragmento de código le muestra cómo usar la Escala de Grises.

Convertir Capas de Imagen GIF a Imagen TIFF

A veces es necesario extraer y convertir capas de una imagen PSD a otro formato de imagen de trama para satisfacer una necesidad de la aplicación. Aspose.PSD API admite la función de extraer y convertir capas de una imagen PSD a otro formato de imagen de trama. En primer lugar, crearemos una instancia de imagen y cargaremos la imagen PSD desde el disco local, luego iteraremos cada capa en la propiedad de Capa. Luego convertiremos el bloque a la imagen TIFF. El siguiente fragmento de código le muestra cómo convertir las capas de imagen PSD a imágenes TIFF.

// 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 + @"output";

// Load a PSD image and Convert the image's layers to Tiff images.
using (PsdImage image = (PsdImage)Image.Load(sourceFile))
{
    // Iterate through array of PSD layers
    for (int i = 0; i < image.Layers.Length; i++)
    {
        // Get PSD layer.
        Layer layer = image.Layers[i];

        // Create an instance of TIFF Option class and Save the PSD layer as TIFF image
        TiffOptions objTiff = new TiffOptions(TiffExpectedFormat.TiffDeflateRgb);
        layer.Save("output" + i + "_out.tif", objTiff);
    }
}

Convertir PSD CMYK a TIFF CMYK

Con Aspose.PSD para .NET, los desarrolladores pueden convertir un archivo PSD CMYK a formato tiff CMYK. Este artículo muestra cómo exportar/convertir un archivo PSD CMYK a formato tiff CMYK con Aspose.PSD. Usando Aspose.PSD para .NET, puede cargar imágenes PSD y luego puede configurar varias propiedades utilizando la clase Opciones de Tiff y guardar o exportar la imagen. El siguiente fragmento de código le muestra cómo lograr esta función.

// 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 + @"output.tiff";

using (Image image = Image.Load(sourceFile))
{
    image.Save(destName, new TiffOptions(TiffExpectedFormat.TiffLzwCmyk));
}

Exportar Imágenes

Junto con un amplio conjunto de rutinas de procesamiento de imágenes, Aspose.PSD proporciona clases especializadas para convertir formatos de archivo PSD a otros formatos. Usando esta biblioteca, la conversión de imágenes PSD es muy simple e intuitiva. A continuación se muestran algunas clases especializadas para este propósito en el espacio de nombres Opciones de Imagen.

• Opciones Bmp
• Opciones Gif
• Opciones Jpeg
• Opciones Jpeg2000
• Opciones Tiff
• Opciones Png

Es fácil exportar imágenes PSD con Aspose.PSD para .NET API. Todo lo que necesita es un objeto de la clase apropiada de Opciones de Imagen. Mediante el uso de estas clases, puede exportar fácilmente cualquier imagen creada, editada o simplemente cargada con Aspose.PSD para .NET a cualquier formato admitido.

Combinar Imágenes

Este ejemplo utiliza la clase Graphics y muestra cómo combinar dos o más imágenes en una sola imagen completa. Para demostrar la operación, el ejemplo crea una nueva PsdImage y dibuja imágenes en la superficie del lienzo utilizando el método Draw Image expuesto por la clase Graphics. Usando la clase Graphics, se pueden combinar dos o más imágenes de tal manera que la imagen resultante se vea como una imagen completa sin espacio entre las partes de la imagen y sin páginas. El tamaño del lienzo debe ser igual al tamaño de la imagen resultante. A continuación se muestra una demostración de código que muestra cómo usar el método DrawImage de la clase Graphics para combinar imágenes en una sola imagen.

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

// Create an instance of PsdOptions and set its various properties
PsdOptions imageOptions = new PsdOptions();

// Create an instance of FileCreateSource and assign it to Source property
imageOptions.Source = new FileCreateSource(dataDir + "Two_images_result_out.psd", false);

// Create an instance of Image and define canvas size
using (var image = Image.Create(imageOptions, 600, 600))
{
    // Create and initialize an instance of Graphics, Clear the image surface with white color and Draw Image
    var graphics = new Graphics(image);
    graphics.Clear(Color.White);
    graphics.DrawImage(Image.Load(dataDir + "example1.psd"), 0, 0, 300, 600);
    graphics.DrawImage(Image.Load(dataDir + "example2.psd"), 300, 0, 300, 600);
    image.Save();
}

Expandir y Recortar Imágenes

La API de Aspose.PSD le permite expandir o recortar una imagen durante el proceso de conversión de imágenes. El desarrollador necesita crear un rectángulo con coordenadas X e Y y especificar el ancho y la altura de la caja rectangular. Las coordenadas X, Y y el ancho, la altura del rectángulo representarán la expansión o el recorte de la imagen cargada. Si es necesario expandir o recortar la imagen durante la conversión de imágenes, realice los siguientes pasos:

1. Cree una instancia de la clase RasterImage y cargue la imagen existente.
2. Cree una instancia de la clase ImageOption.
3. Cree una instancia de la clase Rectangle e inicialice las coordenadas X, Y y el ancho, la altura del rectángulo.
4. Llame al método Save de la clase RasterImage mientras pasa el nombre del archivo de salida, las opciones de imagen y el objeto de rectángulo como parámetros.

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

string sourceFile = dataDir + @"example1.psd";
string destName = dataDir + @"jpeg_out.jpg";

// Load an image in an instance of Image and Setting for image data to be cashed
using (RasterImage rasterImage = (RasterImage)Image.Load(sourceFile))
{
    rasterImage.CacheData();
    // Create an instance of Rectangle class and define X,Y and Width, height of the rectangle, and Save output image
    Rectangle destRect = new Rectangle { X = -200, Y = -200, Width = 300, Height = 300 };
    rasterImage.Save(destName, new JpegOptions(), destRect);
}

Leer y Escribir Datos XMP en Imágenes

XMP (Plataforma de Metadatos Extensible) es un estándar ISO. XMP estandariza un modelo de datos, un formato de serialización y propiedades centrales para la definición y procesamiento de metadatos extensibles. También proporciona pautas para incrustar información XMP en una imagen popular como JPEG, sin afectar su legibilidad por aplicaciones que no admiten XMP. Con la API de Aspose.PSD para .NET, los desarrolladores pueden leer o escribir metadatos XMP en imágenes. Este artículo demuestra cómo se pueden leer metadatos XMP de una imagen y escribir metadatos XMP en imágenes.

Crear Metadatos XMP, Escribirlos y Leerlos Desde un Archivo

Con la ayuda del espacio de nombres Xmp, el desarrollador puede crear un objeto de metadatos XMP y escribirlo en una imagen. El siguiente fragmento de código le muestra cómo usar los paquetes XmpHeaderPi, XmpTrailerPi, XmpMeta, XmpPacketWrapper, PhotoshopPackage y DublinCorePackage contenidos en el espacio de nombres Xmp.

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

// Specify the size of image by defining a Rectangle 
Rectangle rect = new Rectangle(0, 0, 100, 200);

// Create the brand new image just for sample purposes
using (var image = new PsdImage(rect.Width, rect.Height))
{
    // Create an instance of XMP-Header
    XmpHeaderPi xmpHeader = new XmpHeaderPi(Guid.NewGuid().ToString());

    // Create an instance of Xmp-TrailerPi, XMPmeta class to set different attributes
    XmpTrailerPi xmpTrailer = new XmpTrailerPi(true);
    XmpMeta xmpMeta = new XmpMeta();
    xmpMeta.AddAttribute("Author", "Mr Smith");
    xmpMeta.AddAttribute("Description", "The fake metadata value");

    // Create an instance of XmpPacketWrapper that contains all metadata
    XmpPacketWrapper xmpData = new XmpPacketWrapper(xmpHeader, xmpTrailer, xmpMeta);

    // Create an instacne of Photoshop package and set photoshop attributes
    PhotoshopPackage photoshopPackage = new PhotoshopPackage();
    photoshopPackage.SetCity("London");
    photoshopPackage.SetCountry("England");
    photoshopPackage.SetColorMode(ColorMode.Rgb);
    photoshopPackage.SetCreatedDate(DateTime.UtcNow);

    // Add photoshop package into XMP metadata
    xmpData.AddPackage(photoshopPackage);

    // Create an instacne of DublinCore package and set dublinCore attributes
    DublinCorePackage dublinCorePackage = new DublinCorePackage();
    dublinCorePackage.SetAuthor("Mudassir Fayyaz");
    dublinCorePackage.SetTitle("Confessions of a Man Insane Enough to Live With the Beasts");
    dublinCorePackage.AddValue("dc:movie", "Barfly");

    // Add dublinCore Package into XMP metadata
    xmpData.AddPackage(dublinCorePackage);

    using (var ms = new MemoryStream())
    {
        // Update XMP metadata into image and Save image on the disk or in memory stream
        image.XmpData = xmpData;
        image.Save(ms);
        image.Save(dataDir + "ee.psd");
        ms.Seek(0, System.IO.SeekOrigin.Begin);

        // Load the image from memory stream or from disk to read/get the metadata
        using (var img = (PsdImage)Image.Load(ms))
        {
            // Getting the XMP metadata
            XmpPacketWrapper imgXmpData = img.XmpData;
            foreach (XmpPackage package in imgXmpData.Packages)
            {
                // Use package data ...
            }
        }
    }
}

Exportar Imágenes en un Entorno Multihilo

Aspose.PSD para .NET ahora admite la conversión de imágenes en un entorno multihilo. Aspose.PSD para .NET garantiza el rendimiento optimizado de las operaciones durante la ejecución del código en un entorno multihilo. Todas las clases de opciones de imagen (por ejemplo, Opciones Bmp, Opciones Tiff, Opciones Jpeg, etc.) en Aspose.PSD para .NET implementan la interfaz IDisposable. Por lo tanto, es imprescindible que el desarrollador deseche adecuadamente el objeto de clase de opciones de imagen en caso de que se establezca la propiedad Origen. El siguiente fragmento de código demuestra dicha funcionalidad.

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

string imageDataPath = dataDir + @"sample.psd";

try
{

    // Create the stream of the existing image file.   
    using (System.IO.FileStream fileStream = System.IO.File.Create(imageDataPath))
    {

        // Create an instance of PSD image option class.
        using (PsdOptions psdOptions = new PsdOptions())
        {
            // Set the source property of the imaging option class object.
            psdOptions.Source = new Sources.StreamSource(fileStream);

            // DO PROCESSING. 
            // Following is the sample processing on the image. Un-comment to use it.
            //using (RasterImage image = (RasterImage)Image.Create(psdOptions, 10, 10))
            //{
            //    Color[] pixels = new Color[4];
            //    for (int i = 0; i < 4; ++i)
            //    {
            //        pixels[i] = Color.FromArgb(40, 30, 20, 10);
            //    }
            //    image.SavePixels(new Rectangle(0, 0, 2, 2), pixels);
            //    image.Save();
            //}
        }
    }
}
finally
{
    // Delete the file. This statement is in the final block because in any case this statement should execute to make it sure that resource is properly disposed off.
    System.IO.File.Delete(imageDataPath);
}

Aspose.PSD ahora admite la propiedad SyncRoot mientras se trabaja en un entorno multihilo. El desarrollador puede usar esta propiedad para sincronizar el acceso al flujo de origen. El siguiente fragmento de código demuestra cómo se puede utilizar la propiedad SyncRoot.

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

// Create an instance of Memory stream class.
using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream())
{
    // Create an instance of Stream container class and assign memory stream object.
    using (StreamContainer streamContainer = new StreamContainer(memoryStream))
    {
        // check if the access to the stream source is synchronized.
        lock (streamContainer.SyncRoot)
        {
            // do work
            // now access to source MemoryStream is synchronized
        }
    }
}