Tworzenie, Otwieranie i Zapisywanie Obrazów

Tworzenie Plików Obrazów

Aspose.PSD dla .NET pozwala programistom tworzyć własne obrazy. Użyj statycznej metody Create wystawionej przez klasę Image, aby utworzyć nowe obrazy. Wszystko, co musisz zrobić, to dostarczyć odpowiedni obiekt jednej z klas z przestrzeni nazw ImageOptions dla wybranego formatu obrazu wyjściowego. Aby utworzyć plik obrazu, najpierw utwórz egzemplarz jednej z klas z przestrzeni nazw ImageOptions. Te klasy określają format obrazu wyjściowego. Poniżej znajdują się niektóre klasy z przestrzeni nazw ImageOptions (należy zauważyć, że obecnie obsługiwane są tylko formaty plików PSD):

PsdOptions ustawia opcje tworzenia pliku PSD. Pliki obrazów można tworzyć, ustawiając ścieżkę wyjściową lub ustawiając strumień.

Tworzenie poprzez Ustawienie Ścieżki

Utwórz PsdOptions z przestrzeni nazw ImageOptions i ustaw różne właściwości. Najważniejszą właściwością do ustawienia jest Właściwość Source. Ta właściwość określa, gdzie znajdują się dane obrazu (w pliku lub strumieniu). W poniższym przykładzie źródłem jest plik. Po ustawieniu właściwości przekaż obiekt do jednej z statycznych metod Create wraz z parametrami szerokości i wysokości. Szerokość i wysokość są zdefiniowane w pikselach.

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


// Creates an instance of PsdOptions and set its various properties
PsdOptions psdOptions = new PsdOptions();
psdOptions.CompressionMethod = CompressionMethod.RLE;

// Define the source property for the instance of PsdOptions. Second boolean parameter determines if the file is temporal or not
psdOptions.Source = new FileCreateSource(desName, false);

// Creates an instance of Image and call Create method by passing the PsdOptions object
using (Image image = Image.Create(psdOptions, 500, 500))
{
    image.Save();
}

Tworzenie Za Pomocą Strumienia

Proces tworzenia obrazu za pomocą strumienia jest taki sam jak w przypadku użycia ścieżki. Jedyną różnicą jest konieczność utworzenia egzemplarza StreamSource poprzez przekazanie obiektu Stream do jego konstruktora i przypisanie go do właściwości Source.

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

string desName = dataDir + "CreatingImageUsingStream_out.bmp";
// Creates an instance of BmpOptions and set its various properties
BmpOptions ImageOptions = new BmpOptions();
ImageOptions.BitsPerPixel = 24;

// Create an instance of System.IO.Stream
Stream stream = new FileStream(dataDir + "sample_out.bmp", FileMode.Create);

// Define the source property for the instance of BmpOptions Second boolean parameter determines if the Stream is disposed once get out of scope
ImageOptions.Source = new StreamSource(stream, true);

// Creates an instance of Image and call Create method by passing the BmpOptions object
using (Image image = Image.Create(ImageOptions, 500, 500))
{
    // Do some image processing
    image.Save(desName);
}

Otwieranie Plików Obrazów

Programiści mogą używać interfejsu API Aspose.PSD dla .NET do otwierania istniejących plików obrazów PSD do różnych celów, takich jak dodawanie efektów do obrazu lub konwertowanie istniejącego pliku do innego formatu. Bez względu na cel, Aspose.PSD udostępnia dwa standardowe sposoby otwierania istniejących plików: z pliku lub ze strumienia.

Otwieranie z Dysku

Otwórz plik obrazu, przekazując ścieżkę i nazwę pliku jako parametr do statycznej metody Load wystawionej przez klasę Image.

// 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 + "result.png";

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(sourceFile))
{
    PsdImage psdImage = (PsdImage)image;
    psdImage.Save(destName, new PngOptions());
}

Otwieranie za Pomocą Strumienia

Czasami obraz, który musimy otworzyć, jest przechowywany jako strumień. W takich przypadkach użyj przeciążonej wersji metody Load. Ta metoda akceptuje obiekt Stream jako argument do otwarcia 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 + "result.png";

FileStream fStream = new FileStream(sourceFile, FileMode.Open);
fStream.Position = 0;

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(fStream))
{
    PsdImage psdImage = (PsdImage)image;
    MemoryStream stream = new MemoryStream();
    psdImage.Save(stream, new PngOptions());
}

Załaduj Obraz Jako Warstwę

Ten artykuł demonstruje użycie Aspose.PSD do wczytania obrazu jako warstwy. API Aspose.PSD udostępnia wydajne i łatwe w użyciu metody do osiągnięcia tego celu. Aspose.PSD udostępnił metodę AddLayer klasy PsdImage, aby dodać obraz do pliku PSD jako warstwę.

Kroki potrzebne do wczytania obrazu do PSD jako warstwy są tak proste jak poniżej:

• Utwórz egzemplarz obrazu za pomocą klasy PsdImage z określoną szerokością i wysokością.
• Wczytaj plik PSD jako obraz przy użyciu metody fabrycznej Load wystawionej przez klasę Image.
• Utwórz egzemplarz klasy Layer i przypisz do niego warstwę obrazu PSD.
• Dodaj utworzoną warstwę przy użyciu metody AddLayer wystawionej przez klasę PsdImage
• Zapisz wyniki.

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

string filePath = dataDir + "PsdExample.psd";
string outputFilePath = dataDir + "PsdResult.psd";
using (var image = new PsdImage(200, 200))
{
    using (var im = Image.Load(filePath))
    {
        Layer layer = null;
        try
        {
            layer = new Layer((RasterImage)im);
            image.AddLayer(layer);
        }
        catch (Exception e)
        {
            if (layer != null)
            {
                layer.Dispose();
            }
            throw;
        }
    }
    image.Save(outputFilePath);
}

Załaduj Obraz Jako Warstwę ze Strumienia

Ten artykuł demonstruje użycie Aspose.PSD do wczytania obrazu jako warstwy ze strumienia. Aby wczytać obraz ze strumienia, po prostu przekaż obiekt strumienia zawierającego obraz do konstruktora klasy Layer. Dodaj utworzoną warstwę przy użyciu metody AddLayer wystawionej przez klasę PsdImage i zapisz wyniki.

Oto przykładowy kod.

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

string outputFilePath = dataDir + "PsdResult.psd";

var filesList = new string[]
{
    "PsdExample.psd",
    "BmpExample.bmp",
    "GifExample.gif",
    "Jpeg2000Example.jpf",
    "JpegExample.jpg",
    "PngExample.png",
    "TiffExample.tif",
};
using (var image = new PsdImage(200, 200))
{
    foreach (var fileName in filesList)
    {
        string filePath = dataDir + fileName;
        using (var stream = new FileStream(filePath, FileMode.Open))
        {
            Layer layer = null;
            try
            {
                layer = new Layer(stream);
                image.AddLayer(layer);
            }
            catch (Exception e)
            {
                if (layer != null)
                {
                    layer.Dispose();
                }
                throw e;
            }
        }
    }
    image.Save(outputFilePath);
}

Zapisywanie Plików Obrazów

Aspose.PSD pozwala tworzyć pliki obrazów od podstaw. Zapewnia również możliwość edycji istniejących plików obrazów. Po utworzeniu lub zmodyfikowaniu obrazu, plik zazwyczaj jest zapisywany na dysk. Aspose.PSD udostępnia metody do zapisywania obrazów na dysk poprzez określenie ścieżki lub użycie obiektu strumienia.

Zapisywanie do Dysku

Klasa Image reprezentuje obiekt obrazu, dlatego ta klasa dostarcza wszystkie narzędzia potrzebne do tworzenia, wczytywania i zapisywania pliku obrazu. Użyj metody Save klasy Image do zapisywania obrazów. Jedna przeciążona wersja metody Save akceptuje lokalizację pliku jako ciąg.

// 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 + "result.png";

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(sourceFile))
{
    PsdImage psdImage = (PsdImage)image;
    psdImage.Save(destName, new PngOptions());
}

Zapisywanie do Strumienia

Inna przeciążona wersja metody Save akceptuje obiekt Stream jako argument i zapisuje plik obrazu do strumienia.

Jeśli obraz jest utworzony przez określenie któregokolwiek z CreateOptions w konstruktorze Image, obraz automatycznie jest zapisywany do ścieżki lub strumienia podanego podczas inicjalizacji klasy Image, wywołując metodę Save, która nie przyjmuje żadnych parametrów.

// 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 + "result.png";

// load PSD image and replace the non found fonts.
using (Image image = Image.Load(sourceFile))
{
    PsdImage psdImage = (PsdImage)image;
    MemoryStream stream = new MemoryStream();
    psdImage.Save(stream, new PngOptions());
}

Ustawianie Domyślnej Czcionki do zastąpienia brakujących czcionek

Programiści mogą użyć interfejsu API Aspose.PSD dla .NET do wczytania istniejących plików obrazów PSD do różnych celów, na przykład, aby ustawić domyślną nazwę czcionki podczas zapisywania dokumentów PSD jako obraz rastrowy (do formatów PNG, JPG i BMP). Ta domyślna czcionka powinna być używana jako zastępstwo dla wszystkich brakujących czcionek (czcionek, które nie zostały znalezione w bieżącym systemie operacyjnym). Po zmodyfikowaniu obrazu, plik zostanie zapisany na dysku.

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

string sourceFileName = "sample_konstanting.psd";

string[] outputs = new string[]
{
    "replacedfont0.tiff",
    "replacedfont1.png",
    "replacedfont2.jpg"
};

using (PsdImage image = (PsdImage)Image.Load(sourceFileName, new PsdLoadOptions()))
{
    // This way you can use different fonts for different outputs 
    image.Save(outputs[0], new TiffOptions(TiffExpectedFormat.TiffJpegRgb) { DefaultReplacementFont = "Arial" });
    image.Save(outputs[1], new PngOptions { DefaultReplacementFont = "Verdana" });
    image.Save(outputs[2], new JpegOptions { DefaultReplacementFont = "Times New Roman" });
}