Konwersja obrazów

Konwertowanie obrazów na czarno-białe i w odcieniach szarości

Czasami możesz potrzebować konwertować kolorowe obrazy na czarno-białe lub w odcieniach szarości do celów drukowania lub archiwizacji. W tym artykule przedstawiono użycie interfejsu API Aspose.PSD dla .NET do osiągnięcia tego przy użyciu dwóch metod, jak opisano poniżej.

• Binarizacja
• Skalowanie odcieni szarości

Binarizacja

Aby zrozumieć koncepcję binarizacji, ważne jest zdefiniowanie obrazu binarnego; jest to obraz cyfrowy, który może mieć tylko dwie możliwe wartości dla każdego piksela. Zwykle dwa kolory używane do obrazów binarnych to czerń i biel, choć można użyć dowolnych dwóch kolorów. Binarizacja to proces konwertowania obrazu na dwupoziomowy, co oznacza, że każdy piksel jest przechowywany jako pojedynczy bit (0 lub 1), gdzie 0 oznacza brak koloru, a 1 oznacza obecność koloru. Interfejs API Aspose.PSD dla .NET obecnie obsługuje dwie metody binarizacji.

Binarizacja z ustalonym progiem

Poniższy fragment kodu pokazuje, jak można zastosować binarizację z ustalonym progiem do obrazu.

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

Binarizacja z progiem Otsu

Następujący fragment kodu pokazuje, jak można zastosować binarizację z progiem Otsu do obrazu.

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

Skalowanie odcieni szarości

Skalowanie odcieni szarości to proces konwertowania obrazu o ciągłych odcieniach na obraz z nieciągłymi odcieniami szarości. Poniższy fragment kodu pokazuje, jak używać skalowania odcieni szarości.

Konwertowanie warstw obrazów GIF na obrazy TIFF

Czasami konieczne jest wyodrębnienie i konwersja warstw obrazów PSD na inny format obrazu rastrowego, aby spełnić potrzeby aplikacji. Interfejs API Aspose.PSD obsługuje funkcję wyodrębniania i konwertowania warstw obrazów PSD na inny format obrazu rastrowego. Po pierwsze, utworzymy instancję obrazu i wczytamy obraz PSD z dysku lokalnego, a następnie przeiterujemy każdą warstwę w właściwości Layer. Następnie przekonwertujemy blok do obrazu TIFF. Poniższy fragment kodu pokazuje, jak konwertować warstwy obrazów PSD na obrazy 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);
    }
}

Konwertowanie pliku PSD CMYK na format TIFF CMYK

Za pomocą interfejsu Aspose.PSD dla .NET, programiści mogą konwertować plik PSD CMYK na format tiff CMYK. W artykule pokazano, jak wyeksportować/konwertować plik PSD CMYK na format tiff CMYK za pomocą Aspose.PSD. Korzystając z Aspose.PSD dla .NET, można wczytać obrazy PSD, a następnie można ustawić różne właściwości za pomocą TiffOptions klasy i zapisać lub wyeksportować obraz. Poniższy fragment kodu pokazuje, jak osiągnąć tę funkcję.

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

Eksportowanie obrazów

Oprócz bogatego zestawu procedur przetwarzania obrazów, Aspose.PSD zapewnia specjalistyczne klasy do konwertowania formatów plików PSD na inne formaty. Korzystając z tej biblioteki, konwersja obrazów PSD jest bardzo prosta i intuicyjna. Poniżej znajdują się specjalistyczne klasy do tego celu w przestrzeni nazw ImageOptions.

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

Eksportowanie obrazów PSD za pomocą interfejsu API Aspose.PSD dla .NET jest proste. Wszystko, czego potrzebujesz, to obiekt odpowiedniej klasy z przestrzeni nazw ImageOptions. Korzystając z tych klas, łatwo możesz wyeksportować każdy obraz utworzony, edytowany lub po prostu wczytany za pomocą interfejsu Aspose.PSD dla .NET do dowolnie obsługiwanego formatu.

Łączenie obrazów

Ten przykład wykorzystuje klasę Graphics i pokazuje, jak połączyć dwa lub więcej obrazów w pojedynczy obraz kompletu. Aby zademonstrować operację, przykład tworzy nowy obraz PsdImage i rysuje obrazy na powierzchni płótna za pomocą metody Draw Image udostępnionej przez klasę Graphics. Korzystając z klasy Graphics, dwa lub więcej obrazów można połączyć w taki sposób, że wynikowy obraz będzie wyglądał jak kompletny obraz bez odstępów między częściami obrazu i bez stron. Rozmiar płótna musi być równy rozmiarowi obrazu wynikowego. Poniżej znajduje się przykład kodu pokazujący, jak korzystać z metody DrawImage klasy Graphics do łączenia obrazów w pojedynczy obraz.

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

Rozszerzanie i Przycinanie obrazów

Interfejs API Aspose.PSD pozwala na rozszerzanie lub przycinanie obrazu podczas procesu konwersji obrazu. Programista musi utworzyć prostokąt z współrzędnymi X i Y oraz określić szerokość i wysokość prostokąta. Współrzędne X, Y oraz szerokość i wysokość prostokąta będą odzwierciedlały rozszerzanie lub przycinanie wczytanego obrazu. Jeśli podczas konwersji obrazu konieczne jest rozszerzenie lub przycięcie obrazu, wykonaj następujące kroki:

1. Utwórz instancję klasy RasterImage i wczytaj istniejący obraz.
2. Utwórz instancję klasy ImageOption.
3. Utwórz instancję klasy Rectangle i zainicjuj współrzędne X, Y oraz szerokość i wysokość prostokąta.
4. Wywołaj Save metodę klasy RasterImage, podając nazwę pliku wyjściowego, opcje obrazu i obiekt prostokąta jako parametry.

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

Odczytywanie i Zapisywanie danych XMP do obrazów

XMP (Extensible Metadata Platform) to standard ISO. XMP standaryzuje model danych, format serializacji oraz podstawowe właściwości dla definicji i przetwarzania metadanych rozszerzalnych. Zapewnia również wytyczne dotyczące osadzania informacji XMP w popularnym obrazie, takim jak JPEG, bez utraty czytelności dla aplikacji, które nie obsługują XMP. Korzystając z interfejsu API Aspose.PSD dla .NET, programiści mogą odczytywać lub zapisywać metadane XMP do obrazów. Ten artykuł demonstruje, jak metadane XMP mogą być odczytywane z obrazu i zapisywane do obrazów.

Utwórz obiekt metadanych XMP, Zapisz go i Oczytaj z Pliku

Za pomocą przestrzeni nazw Xmp programista może utworzyć obiekt metadanych XMP i zapisać go do obrazu. Poniższy fragment kodu pokazuje, jak używać pakietów XmpHeaderPi, XmpTrailerPi, XmpMeta, XmpPacketWrapper, PhotoshopPackage i DublinCorePackage zawartych w przestrzeni nazw 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 ...
            }
        }
    }
}

Eksportowanie obrazów w środowisku wielowątkowym

Aspose.PSD dla .NET teraz obsługuje konwersję obrazów w środowisku wielowątkowym. Aspose.PSD dla .NET zapewnia zoptymalizowaną wydajność operacji podczas wykonywania kodu w środowisku wielowątkowym. Wszystkie klasy opcji obrazów (np. BmpOptions, TiffOptions, JpegOptions, itp.) w Aspose.PSD dla .NET implementują interfejs IDisposable. Dlatego konieczne jest prawidłowe zwolnienie obiektu klasy opcji obrazu w przypadku ustawienia właściwości Source. Poniższy fragment kodu demonstruje tę funkcjonalność.

// 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 obsługuje teraz właściwość SyncRoot podczas pracy w środowisku wielowątkowym. Programista może użyć tej właściwości do synchronizacji dostępu do strumienia źródłowego. Poniższy fragment kodu demonstruje, jak można użyć właściwości 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
        }
    }
}