Bilder konvertieren

Bilder in Schwarzweiß und Graustufen umwandeln

Manchmal müssen farbige Bilder für Druck- oder Archivierungszwecke in Schwarzweiß oder Graustufen umgewandelt werden. Dieser Artikel zeigt die Verwendung der Aspose.PSD für die .NET-API, um dies mit zwei unten aufgeführten Methoden zu erreichen.

• Binarisierung
• Grauskalierung

Binarisierung

Um das Konzept der Binarisierung zu verstehen, ist es wichtig, ein Binärbild zu definieren; das ist ein digitales Bild, das für jeden Pixel nur zwei mögliche Werte haben kann. Normalerweise werden für ein Binärbild die beiden Farben Schwarz und Weiß verwendet, obwohl jede beliebige Farbe verwendet werden kann. Binarisierung ist der Prozess der Umwandlung eines Bildes in schwarz-weiß, was bedeutet, dass jeder Pixel als ein einzelnes Bit (0 oder 1) gespeichert wird, wobei 0 das Fehlen von Farbe bedeutet und 1 das Vorhandensein von Farbe. Die Aspose.PSD für .NET-API unterstützt derzeit zwei Binarisierungsmethoden.

Binarisierung mit festem Schwellenwert

Der folgende Code-Ausschnitt zeigt, wie der feste Schwellenwert binarisiert angewendet werden kann.

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

Binarisierung mit Otsu-Schwellenwert

Der folgende Code-Ausschnitt zeigt, wie die Otsu-Schwellenwert binarisierte auf ein Bild angewendet wird.

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

Grauskalierung

Grauskalierung ist der Prozess der Umwandlung eines kontinuierlichen Tonbildes in ein Bild mit diskreten Grautönen. Der folgende Codeausschnitt zeigt, wie die Grauskalierung verwendet wird.

GIF-Bildschichten in TIFF-Bild umwandeln

Manchmal ist es erforderlich, Ebenen eines PSD-Bildes in ein anderes Rasterbildformat zu extrahieren und umzuwandeln, um den Anforderungen einer Anwendung gerecht zu werden. Die Aspose.PSD-API unterstützt das Extrahieren und Umwandeln von Ebenen eines PSD-Bildes in ein anderes Rasterbildformat. Zunächst werden wir eine Instanz des Bildes erstellen und das PSD-Bild von der lokalen Festplatte laden, dann werden wir jede Ebene im Layer-Eigenschaft iterieren. Dann werden wir den Block in ein TIFF-Bild umwandeln. Der folgende Codeausschnitt zeigt, wie PSD-Bildebenen in TIFF-Bilder konvertiert werden.

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

Konvertieren von CMYK-PSD in CMYK-TIFF

Mit Aspose.PSD für .NET können Entwickler eine CMYK-PSD-Datei in das CMYK-Tiff-Format konvertieren. Dieser Artikel zeigt, wie eine CMYK-PSD-Datei ins CMYK-Tiff-Format exportiert/konvertiert werden kann mit Aspose.PSD. Mit Aspose.PSD für .NET können Sie PSD-Bilder laden und verschiedene Eigenschaften mit der TiffOptions-Klasse einstellen und das Bild speichern oder exportieren. Der folgende Codeausschnitt zeigt, wie dies erreicht werden kann.

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

Bilder exportieren

Neben einem umfangreichen Satz von Bildverarbeitungsroutinen bietet Aspose.PSD spezialisierte Klassen zum Konvertieren von PSD-Dateiformaten in andere Formate. Mit dieser Bibliothek ist die Konvertierung von PSD-Bildern sehr einfach und intuitiv. Hier sind einige spezialisierte Klassen für diesen Zweck im ImageOptions-Namespace.

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

Es ist einfach, PSD-Bilder mit der Aspose.PSD für die .NET-API zu exportieren. Alles was Sie brauchen, ist ein Objekt der entsprechenden Klasse aus dem ImageOptions-Namespace. Mit diesen Klassen können Sie jedes Bild, das mit Aspose.PSD für .NET erstellt, bearbeitet oder einfach geladen wurde, leicht in ein beliebiges unterstütztes Format exportieren.

Bilder kombinieren

Dieses Beispiel verwendet die Graphics-Klasse und zeigt, wie zwei oder mehr Bilder zu einem einzigen vollständigen Bild kombiniert werden können. Zur Veranschaulichung erstellt das Beispiel ein neues PsdImage und zeichnet Bilder auf der Leinwandfläche unter Verwendung der von der Graphics-Klasse bereitgestellten Draw-Image-Methode. Mit der Graphics-Klasse können zwei oder mehr Bilder so kombiniert werden, dass das resultierende Bild wie ein vollständiges Bild aussieht, ohne Platz zwischen den Bildteilen und ohne Seiten. Die Leinwandgröße muss der Größe des resultierenden Bildes entsprechen. Im Folgenden ist die Code-Demonstration, die zeigt, wie die DrawImage-Methode der Graphics-Klasse verwendet wird, um Bilder zu kombinieren.

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

Bilder erweitern und zuschneiden

Aspose.PSD API ermöglicht es Ihnen, ein Bild während des Bildkonvertierungsprozesses zu erweitern oder zuzuschneiden. Der Entwickler muss ein Rechteck mit X- und Y-Koordinaten erstellen und die Breite und Höhe der Rechteckbox angeben. Die X-, Y- und Breite-, Höhe des Rechtecks geben die Erweiterung oder das Zuschneiden des geladenen Bildes an. Wenn erforderlich, das Bild während der Bildkonvertierung zu erweitern oder zuzuschneiden, führen Sie folgende Schritte aus:

1. Erstellen Sie eine Instanz der RasterImage-Klasse und laden Sie das vorhandene Bild.
2. Erstellen Sie eine Instanz der ImageOption-Klasse.
3. Erstellen Sie eine Instanz der Rectangle-Klasse und initialisieren Sie die X,Y- und Breite-, Höhe des Rechtecks
4. Rufen Sie die Save-Methode der RasterImage-Klasse auf, wobei Ausgabedateiname, Bilddateioptionen und das Rechteckobjekt als Parameter übergeben werden.

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

XMP-Daten in Bilder schreiben und lesen

XMP (Extensible Metadata Platform) ist ein ISO-Standard. XMP standardisiert ein Datenmodell, ein Serialisierungsformat und Kern-Eigenschaften für die Definition und Verarbeitung von erweiterbaren Metadaten. Es gibt auch Richtlinien dafür, wie XMP-Informationen in ein beliebtes Bild wie JPEG eingebettet werden können, ohne die Lesbarkeit durch Anwendungen zu beeinträchtigen, die XMP nicht unterstützen. Mit der Aspose.PSD für .NET-API können Entwickler XMP-Metadaten in Bilder einlesen oder schreiben. Dieser Artikel zeigt, wie XMP-Metadaten aus einem Bild gelesen und in Bilder geschrieben werden können.

Erstellen von XMP-Metadaten, Schreiben und Lesen aus Datei

Mit Hilfe des Xmp-Namespaces kann der Entwickler ein XMP-Metadatenobjekt erstellen und es in ein Bild schreiben. Der folgende Code-Ausschnitt zeigt, wie die im Xmp-Namespace enthaltenen XmpHeaderPi, XmpTrailerPi, XmpMeta, XmpPacketWrapper, PhotoshopPackage und DublinCorePackage-Pakete verwendet werden.

// 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 ...
            }
        }
    }
}

Bilder in einer Mehrfadenumgebung exportieren

Aspose.PSD für .NET unterstützt jetzt das Konvertieren von Bildern in einer mehrfädigen Umgebung. Aspose.PSD für .NET gewährleistet eine optimierte Leistung von Operationen während der Ausführung von Code in einer mehrfädigen Umgebung. Alle Bildoption-Klassen (z. B. BmpOptions, TiffOptions, JpegOptions usw.) in Aspose.PSD für .NET implementieren das IDisposable-Interface. Daher ist es erforderlich, dass der Entwickler das Objekt der Bildoptionenklasse ordnungsgemäß freigibt, falls die Source-Eigenschaft gesetzt ist. Der folgende Code-Ausschnitt zeigt die Funktionalität.

// 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 unterstützt jetzt die SyncRoot-Eigenschaft bei der Arbeit in einer mehrfädigen Umgebung. Der Entwickler kann diese Eigenschaft verwenden, um auf den Quellstrom zuzugreifen. Der folgende Code-Ausschnitt zeigt, wie die SyncRoot-Eigenschaft verwendet werden kann.

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