Konwertowanie obrazów

Konwertowanie obrazów na czarno-białe oraz odcienie szarości

Czasami może być konieczne konwertowanie obrazów kolorowych na czarno-białe lub odcienie szarości do celów drukowania lub archiwizacji. Ten artykuł przedstawia użycie interfejsu API Aspose.PSD dla Javy w celu osiągnięcia tego za pomocą dwóch wymienionych poniżej metod.

• Binarnizacja
• Skalowanie odcieni szarości

Binarnizacja

Aby zrozumieć pojęcie binarnizacji, 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. Zazwyczaj używane są dwa kolory dla obrazu binarnego: czarny i biały, choć można użyć dowolnych dwóch kolorów. Binarnizacja polega na przekształceniu 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 Javy obecnie obsługuje dwie metody binarnizacji.

Binarnizacja z ustalonym progiem

Poniższy fragment kodu pokazuje, jak stosować binarnizację ze stałym progiem do obrazu.

        String dataDir = Utils.getDataDir(BinarizationWithFixedThreshold.class) + "Conversion/";

        String sourceFile = dataDir + "sample.psd";
        String destName = dataDir + "BinarizationWithFixedThreshold_out.jpg";

        try (Image image = Image.load(sourceFile);
             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((byte) 100);
            rasterCachedImage.save(destName, new JpegOptions());
        }

Binarnizacja z progiem Otsu

Poniższy fragment kodu pokazuje, jak stosować binarnizację z progiem Otsu do obrazu.

        String dataDir = Utils.getDataDir(BinarizationWithOtsuThreshold.class) + "Conversion/";

        String sourceFile = dataDir + "sample.psd";
        String destName = dataDir + "BinarizationWithOtsuThreshold_out.jpg";

        try (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 polega na przekształceniu obrazu o ciągłym tonie na obraz z nieciągłymi odcieniami szarości. Poniższy fragment kodu pokazuje, jak stosować skalowanie odcieni szarości.

        String dataDir = Utils.getDataDir(GrayScaling.class) + "Conversion/";

        String sourceFile = dataDir + "sample.psd";
        String destName = dataDir + "Grayscaling_out.jpg";

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

            // Transform image to its grayscale representation and Save the resultant image
            rasterCachedImage.grayscale();
            rasterCachedImage.save(destName, new JpegOptions());
        }

Konwertowanie warstw obrazu GIF na obraz TIFF

Czasami konieczne jest wyodrębnienie i konwersja warstw obrazu PSD na inny format obrazu rastrowego, aby sprostać potrzebom aplikacji. Interfejs API Aspose.PSD obsługuje funkcję wyodrębnienia i konwersji warstw obrazu PSD na inny format obrazu rastrowego. Na początku stworzymy instancję obrazu i wczytamy obraz PSD z dysku lokalnego, a następnie będziemy iterować przez każdą warstwę w właściwości Layer. Następnie przekonwertujemy blok na obraz TIFF. Poniższy fragment kodu pokazuje, jak konwertować warstwy obrazu PSD na obrazy TIFF.

        String dataDir = Utils.getDataDir(GIFImageLayersToTIFF.class) + "Conversion/";

        String sourceFile = dataDir + "sample.psd";

        // Load a PSD image and Convert the image's layers to Tiff images.
        try (PsdImage image = (PsdImage) Image.load(sourceFile)) {
            // Iterate through array of PSD layers
            for (int i = 0; i < image.getLayers().length; i++) {
                // Get PSD layer.
                Layer layer = image.getLayers()[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.tiff", objTiff);
            }
        }

Konwertowanie pliku CMYK PSD na TIFF CMYK

Za pomocą Aspose.PSD dla Javy programiści mogą konwertować plik CMYK PSD na format tiff CMYK. Ten artykuł pokazuje, jak wyeksportować / skonwertować plik CMYK PSD na format tiff CMYK za pomocą Aspose.PSD. Za pomocą Aspose.PSD dla Javy można wczytywać obrazy PSD, a następnie można ustawiać różne właściwości za pomocą klasy TiffOptions i zapisywać lub eksportować obraz. Poniższy fragment kodu pokazuje, jak osiągnąć tę funkcjonalność.

        String dataDir = Utils.getDataDir(CMYKPSDtoCMYKTiff.class) + "Conversion/";

        String sourceFile = dataDir + "sample.psd";
        String destName = dataDir + "output.tiff";

        try (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 dostarcza specjalizowane 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ę specjalizowane klasy do tego celu w przestrzeni nazw ImageOptions.

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

Eksportowanie obrazów PSD jest łatwe dzięki interfejsowi API Aspose.PSD dla Javy. Wszystko, czego potrzebujesz, to obiekt odpowiedniej klasy z przestrzeni nazw ImageOptions. Korzystając z tych klas, możesz łatwo eksportować dowolny obraz utworzony, edytowany lub po prostu wczytany za pomocą Aspose.PSD dla Javy do dowolnego 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 kompletny obraz. 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, możesz połączyć dwa lub więcej obrazów w taki sposób, że rezultatowa połączony obraz będzie wyglądać jak kompletny obraz bez miejsc pomiędzy częściami obrazu i bez marginesów. Wielkość płótna musi być równa wielkości wynikowego obrazu. Poniżej znajduje się demonstracja kodu pokazująca, jak użyć metody Draw Image klasy Graphics do łączenia obrazów w jeden obraz.

        String dataDir = Utils.getDataDir(CombiningImages.class) + "DrawingAndFormattingImages/";

// 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.setSource(new FileCreateSource(dataDir + "Two_images_result_out.psd", false));

        try (Image image = Image.create(imageOptions, 600, 600)) {
            // Create and initialize an instance of Graphics, Clear the image surface with white color and Draw Image
            Graphics graphics = new Graphics(image);
            graphics.clear(Color.getWhite());
            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 umożliwia rozszerzanie lub przycinanie obrazu podczas procesu konwersji obrazów. 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ą określać rozszerzanie lub przycinanie wczytanego obrazu. Jeśli podczas konwersji obrazu jest wymagane jego rozszerzanie lub przycinanie, 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 metodę Save klasy RasterImage, przekazując nazwę pliku wyjściowego, opcje obrazu i obiekt prostokąta jako parametry.

        String dataDir = Utils.getDataDir(ExpandAndCropImages.class) + "DrawingAndFormattingImages/";

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

        try (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(-200, -200, 300, 300);
            rasterImage.save(destName, new JpegOptions(), destRect);
        }

Odczytanie i Zapisanie danych XMP do obrazów

XMP (Extensible Metadata Platform) to standard ISO. XMP standaryzuje model danych, format serializacji i podstawowe właściwości do definiowania i przetwarzania metadanych rozszerzalnych. Zapewnia również wskazówki dotyczące osadzania informacji XMP w popularnych formatach obrazów, takich jak JPEG, bez zagrożenia ich czytelności przez aplikacje, które nie obsługują XMP. Za pomocą interfejsu API Aspose.PSD dla Javy programiści mogą odczytywać lub zapisywać metadane XMP do obrazów. Ten artykuł przedstawia, jak metadane XMP mogą być odczytywane z obrazu i jak metadane XMP można zapisywać do obrazów.

Utwórz metadane XMP, zapisz je i odczytaj z pliku

Dzięki przestrzeni nazw XMP deweloper może utworzyć obiekt metadanych XMP i zapisać go do obrazu. Poniższy fragment kodu pokazuje, jak korzystać z pakietów XmpHeaderPi, XmpTrailerPi, XmpMeta, XmpPacketWrapper, PhotoshopPackage i DublinCorePackage zawartych w przestrzeni nazw XMP.

        String dataDir = Utils.getDataDir(CreateXMPMetadata.class) + "DrawingAndFormattingImages/";

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

        try (PsdImage image = new PsdImage(rect.getWidth(), rect.getHeight())) {
            // create an instance of XMP-Header
            XmpHeaderPi xmpHeader = new XmpHeaderPi();
            xmpHeader.setGuid(dataDir);
            // create an instance of Xmp-TrailerPi 
            XmpTrailerPi xmpTrailer = new XmpTrailerPi(true);

            // create an instance of XMPmeta class to set different attributes
            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);

            // 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("Charles Bukowski");
            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);

            MemoryStream ms = new MemoryStream();
            // update XMP metadata into image
            image.setXmpData(xmpData);

            // Save image on the disk or in memory stream
            image.save(dataDir + "create_XMP_Metadata.psd");
        }

Eksportowanie obrazów w środowisku wielowątkowym

Aspose.PSD dla Javy obsługuje teraz konwertowanie obrazów w środowisku wielowątkowym. Aspose.PSD dla Javy zapewnia zoptymalizowaną wydajność operacji podczas wykonywania kodu w środowisku wielowątkowym. Wszystkie klasy opcji obrazu (np. BmpOptions, TiffOptions, JpegOptions, itp.) w Aspose.PSD dla Javy implementują interfejs IDisposable. Dlatego konieczne jest, aby deweloper prawidłowo zwolnił obiekt klasy opcji obrazu w przypadku ustawienia właściwości źródłowej. Poniższy fragment kodu demonstruje tę funkcjonalność.

        String dataDir = Utils.getDataDir(ExportImagesinMultiThreadEnv.class) + "Conversion/";

        String imageDataPath = dataDir + "sample.psd";
        try {
            FileInputStream fileStream = new FileInputStream(imageDataPath);

            PsdOptions psdOptions = new PsdOptions();
            
// Set the source property of the imaging option class object.      
            psdOptions.setSource(new StreamSource(fileStream));

// Following is the sample processing on the image.
            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 output file.
            File f = new File(imageDataPath);
            if (f.exists()) {
                f.delete();
            }
        }

Aspose.PSD teraz obsługuje właściwość SyncRoot podczas pracy w środowisku wielowątkowym. Deweloper może użyć tej właściwości do synchronizacji dostępu do strumienia źródłowego. Poniższy fragment kodu demonstruje, w jaki sposób można użyć właściwości SyncRoot.

        String dataDir = Utils.getDataDir(SyncRoot.class) + "Conversion/";
        
        // Create an instance of Stream container class and assign memory stream object.
        StreamContainer streamContainer = new StreamContainer(new java.io.ByteArrayInputStream(new byte[0]));

        try {
            // check if the access to the stream source is synchronized.
            synchronized (streamContainer.getSyncRoot()) {
                // do work
                // now access to streamContainer is synchronized
            }
        } finally {
            streamContainer.dispose();
        }