Conversione delle immagini

Conversione delle immagini in bianco e nero e scala di grigi

A volte potresti aver bisogno di convertire immagini a colori in bianco e nero o in scala di grigi per scopi di stampa o archiviazione. Questo articolo illustra l’uso di Aspose.PSD per l’API .NET per raggiungere questo scopo utilizzando due metodi come indicato di seguito.

• Binariazione
• Scala di grigi

Binariazione

Per capire il concetto di binariazione, è importante definire un’immagine binaria; cioè un’immagine digitale che può avere solo due possibili valori per ogni pixel. Normalmente, i due colori utilizzati per un’immagine binaria sono il nero e il bianco anche se possono essere usati qualsiasi due colori. La binarizzazione è il processo di conversione di un’immagine in bianco e nero, il che significa che ogni pixel è memorizzato come un singolo bit (0 o 1) dove 0 indica l’assenza di colore e 1 significa presenza di colore. Attualmente, Aspose.PSD per .NET API supporta due metodi di binariazione.

Binariazione con soglia fissa

Il seguente frammento di codice ti mostra come utilizzare la binariazione con soglia fissa per applicarla a un’immagine.

// 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());
}

Binariazione con soglia di Otsu

Il seguente frammento di codice ti mostra come applicare la binariazione con soglia di Otsu a un’immagine.

// 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());
}

Scala di grigi

La scala di grigi è il processo di conversione di un’immagine a toni continui in un’immagine con sfumature di grigio discontinuo. Il seguente frammento di codice ti mostra come utilizzare la Scala di grigi.

Convertire i livelli di immagine GIF in immagine TIFF

A volte è necessario estrarre e convertire i livelli di un’immagine PSD in un’altra immagine raster per soddisfare le esigenze di un’applicazione. L’API di Aspose.PSD supporta la funzionalità di estrazione e conversione dei livelli di un’immagine PSD in un’altra immagine raster. Innanzitutto, creeremo un’istanza dell’immagine e caricheremo l’immagine PSD dal disco locale, quindi iteraeremo su ogni livello nella proprietà Layer. Quindi convertiremo il blocco in immagine TIFF. Il seguente frammento di codice ti mostra come convertire i livelli di un’immagine PSD in immagini 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);
    }
}

Conversione di PSD CMYK in TIFF CMYK

Utilizzando Aspose.PSD per .NET, i programmatori possono convertire un file PSD CMYK in formato TIFF CMYK. Questo articolo mostra come esportare / convertire un file PSD CMYK in formato TIFF CMYK con Aspose.PSD. Utilizzando Aspose.PSD per .NET è possibile caricare immagini PSD e quindi è possibile impostare diverse proprietà utilizzando la classe TiffOptions e salvare o esportare l’immagine. Il seguente frammento di codice mostra come ottenere questa funzionalità.

// 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));
}

Esportazione di immagini

Oltre a un ricco insieme di routine di elaborazione delle immagini, Aspose.PSD fornisce classi specializzate per convertire i formati dei file PSD in altri formati. Utilizzando questa libreria, la conversione delle immagini PSD è molto semplice e intuitiva. Di seguito sono riportate alcune classi specializzate per questo scopo nel ImageOptions namespace.

• BmpOptions
• GifOptions
• JpegOptions
• Jpeg2000Options
• TiffOptions
• PngOptions

È facile esportare le immagini PSD con Aspose.PSD for .NET API. Tutto ciò di cui hai bisogno è un oggetto della classe appropriata da ImageOptions namespace. Utilizzando queste classi, è possibile esportare facilmente qualsiasi immagine creata, modificata o semplicemente caricata con Aspose.PSD for .NET in qualsiasi formato supportato.

Unione di immagini

Questo esempio utilizza la classe Graphics e mostra come combinare due o più immagini in un’unica immagine completa. Per dimostrare l’operazione, l’esempio crea una nuova PsdImage e disegna le immagini sulla superficie del canvas utilizzando il metodo DrawImage esposto dalla classe Graphics. Utilizzando la classe Graphics, due o più immagini possono essere combinate in modo che l’immagine risultante sembri un’immagine completa senza spazio tra le parti dell’immagine e senza pagine. La dimensione del canvas deve essere uguale alla dimensione dell’immagine risultante. Di seguito è riportata la dimostrazione del codice che mostra come utilizzare il metodo DrawImage della classe Graphics per combinare le immagini in un’unica immagine.

// 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();
}

Espandere e ritagliare immagini

L’API Aspose.PSD ti consente di espandere o ritagliare un’immagine durante il processo di conversione dell’immagine. Il programmatore deve creare un rettangolo con coordinate X e Y e specificare la larghezza e l’altezza del rettangolo. Le coordinate X, Y e larghezza, altezza del rettangolo mostreranno l’espansione o il ritaglio dell’immagine caricata. Se è necessario espandere o ritagliare l’immagine durante la conversione dell’immagine, eseguire i seguenti passaggi:

1. Creare un’istanza della classe RasterImage e caricare l’immagine esistente.
2. Creare un’istanza della classe ImageOption.
3. Creare un’istanza della classe Rectangle e inizializzare le coordinate X,Y e larghezza, altezza del rettangolo.
4. Chiamare il metodo Save della classe RasterImage passando il nome del file di output, le opzioni dell’immagine e l’oggetto rettangolo come parametri.

// 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);
}

Leggere e scrivere dati XMP nelle immagini

XMP (Extensible Metadata Platform) è uno standard ISO. XMP standardizza un modello di dati, un formato di serializzazione e proprietà principali per la definizione e l’elaborazione di metadati estensibili. Fornisce anche linee guida per l’incorporazione di informazioni XMP in un’immagine popolare come JPEG, senza comprometterne la leggibilità da parte di applicazioni che non supportano XMP. Utilizzando l’API Aspose.PSD per .NET, i programmatori possono leggere o scrivere metadati XMP nelle immagini. Questo articolo dimostra come i metadati XMP possono essere letti da un’immagine e come i metadati XMP possono essere scritti nelle immagini.

Creare metadati XMP, scriverli e leggerli dal file

Con l’aiuto dello spazio dei nomi Xmp, il programmatore può creare un oggetto di metadati XMP e scriverlo nell’immagine. Il seguente frammento di codice mostra come utilizzare i pacchetti XmpHeaderPi, XmpTrailerPi, XmpMeta, XmpPacketWrapper, PhotoshopPackage e DublinCorePackage contenuti nello spazio dei nomi 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 ...
            }
        }
    }
}

Esportare immagini in ambiente multi-threaded

Aspose.PSD per .NET supporta ora la conversione delle immagini in un ambiente multi-threaded. Aspose.PSD per .NET garantisce le prestazioni ottimizzate delle operazioni durante l’esecuzione del codice in un ambiente multi-threaded. Tutte le classi delle opzioni per l’immagine (ad esempio BmpOptions, TiffOptions, JpegOptions, ecc.) in Aspose.PSD for .NET implementano l’interfaccia IDisposable. Pertanto, è importante che il programmatore disponga correttamente dell’oggetto della classe delle opzioni dell’immagine nel caso in cui la proprietà Source sia impostata. Il seguente frammento di codice dimostra la funzionalità menzionata.

// 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 supporta ora la proprietà SyncRoot durante il lavoro in un ambiente multi-threaded. Il programmatore può utilizzare questa proprietà per sincronizzare l’accesso allo stream di origine. Il seguente frammento di codice mostra come può essere utilizzata la proprietà 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
        }
    }
}