Manipulowanie formatami Adobe Photoshop

Łączenie warstw PSD z innymi warstwami

Eksportowanie obrazu do PSD

PSD, dokument PhotoShop, to domyślny format pliku używany przez Adobe Photoshop do pracy z obrazami. Aspose.PSD pozwala na wczytywanie, edytowanie i zapisywanie plików do formatu PSD, dzięki czemu mogą być one otwierane i edytowane w Photoshopie. Ten artykuł pokazuje, jak zapisać plik do formatu PSD przy użyciu Aspose.PSD, omawiając również niektóre ustawienia, które można użyć podczas zapisywania w tym formacie. PsdOptions to specjalizowana klasa w przestrzeni nazw ImageOptions, używana do eksportowania obrazów do formatu PSD. Aby wyeksportować do PSD, wykonaj instancję klasy Image, która jest albo wczytana z istniejącego pliku obrazu (np. miniaturki), albo utworzona od podstaw. Ten artykuł wyjaśnia, jak to zrobić. W poniższych przykładach obraz jest tworzony od podstaw. Po stworzeniu i wypełnieniu danych pikseli zapisz obraz, używając metody Save klasy Image, i przekaż obiekt PsdOptions jako drugi argument. Kilka właściwości klasy PsdOptions może zostać ustawionych dla zaawansowanej konwersji. Niektóre z właściwości to ColorMode, CompressionMethod i Versio…

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

// Create a new image from scratch.
using (PsdImage image = new PsdImage(300, 300))
{
    // Fill image data.
    Graphics graphics = new Graphics(image);
    graphics.Clear(Color.White);
    var pen = new Pen(Color.Brown);
    graphics.DrawRectangle(pen, image.Bounds);

    // Create an instance of PsdOptions, Set it's various properties Save image to disk in PSD format
    PsdOptions psdOptions = new PsdOptions();
    psdOptions.ColorMode = ColorModes.Rgb;
    psdOptions.CompressionMethod = CompressionMethod.Raw;
    psdOptions.Version = 4;
    image.Save(dataDir + "ExportImageToPSD_output.psd", psdOptions);
}

Importowanie obrazu do warstwy PSD

Ten artykuł demonstruje wykorzystanie Aspose.PSD do dodawania lub importowania obrazu do warstwy PSD. Interfejsy API Aspose.PSD udostępniają efektywne i łatwe w użyciu metody do osiągnięcia tego celu. Aspose.PSD udostępnia metodę DrawImage klasy Layer, aby dodać/przenieść obraz do pliku PSD. Metoda DrawImage wymaga podania lokalizacji i wartości obrazu, aby dodać/przenieść obraz do pliku PSD. Kroki do importowania obrazu do warstwy PSD są proste, jak poniżej:

• Wczytaj plik PSD jako obraz, używając metody fabrycznej Load udostępnionej przez klasę Image.
• Utwórz instancję klasy Layer z plikiem Png, Jpeg, Tiff, Gif, Bmp, Psd lub j2k
• Dodaj warstwę do PSD używając metody AddLayer
• Zapisz wyniki.

Poniższy fragment kodu pokazuje, jak importować obraz do warstwy PSD.

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

Zastępowanie kolorów w warstwach PSD

Ten artykuł demonstruje wykorzystanie Aspose.PSD do dodawania lub importowania obrazu do warstwy PSD. Interfejsy API Aspose.PSD udostępniają efektywne i łatwe w użyciu metody do osiągnięcia tego celu. Aspose.PSD udostępnia metodę DrawImage klasy Layer do dodawania/importowania obrazu do pliku PSD. Metoda DrawImage wymaga podania lokalizacji i wartości obrazu do dodania/importowania obrazu do pliku PSD. Kroki do importowania obrazu do warstwy PSD są proste, jak poniżej:

• Wczytaj plik PSD jako obraz, używając metody fabrycznej Load udostępnionej przez klasę Image.
• Utwórz instancję klasy Layer i przypisz warstwę obrazu PSD do niej.
• Wczytaj obraz, który ma zostać dodany lub stwórz jeden od podstaw.
• Wywołaj metodę Layer.DrawImage, podając lokalizację i instancję obrazu.
• Zapisz wyniki.

Poniższy fragment kodu pokazuje, jak importować obraz do warstwy PSD.

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

// Load a PSD file as an image and caste it into PsdImage
using (PsdImage image = (PsdImage)Image.Load(dataDir + "sample.psd"))
{
    foreach (var layer in image.Layers)
    {
        if (layer.Name == "Rectangle 1")
        {
            layer.HasBackgroundColor = true;
            layer.BackgroundColor = Color.Orange;
        }

    }

    image.Save(dataDir + "asposeImage02.psd");
}

Tworzenie miniatur z plików PSD

PSD jest natywnym formatem dokumentu aplikacji Adobe Photoshop. Adobe Photoshop (wersja 5.0 i nowsze) przechowuje informacje o miniaturach do podglądu w bloku zasobów obrazu, który składa się z początkowego nagłówka 28 bajtów, a następnie miniatury JFIF w kolejności RGB (czerwony, zielony, niebieski). API Aspose.PSD zapewnia łatwy w użyciu mechanizm dostępu do zasobów pliku PSD. Te zasoby obejmują również zasób miniatury, który z kolei może być pobrany i zapisany na dysku zgodnie z potrzebami aplikacji. Poniższy fragment kodu pokazuje, jak tworzyć miniatury z plików PSD.

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

// Load a PSD file as an image and caste it into PsdImage
using (PsdImage image = (PsdImage)Image.Load(dataDir + "sample.psd"))
{
    int index = 0;
    // Iterate over the PSD resources
    foreach (var resource in image.ImageResources)
    {
        index++;
        // Check if the resource is of thumbnail type
        if (resource is ThumbnailResource)
        {
            // Retrieve the ThumbnailResource and Check the format of the ThumbnailResource
            var thumbnail = (ThumbnailResource)resource;
            if (thumbnail.Format == ThumbnailFormat.KJpegRgb)
            {
                // Create a new image by specifying the width and height,  Store the pixels of thumbnail on to the newly created image and save image
                PsdImage thumnailImage = new PsdImage(thumbnail.Width, thumbnail.Height);

                thumnailImage.SavePixels(thumnailImage.Bounds, thumbnail.ThumbnailData);
                thumnailImage.Save(dataDir + "CreateThumbnailsFromPSDFiles_out_" + index.ToString() + ".bmp", new BmpOptions());
            }
        }
    }
}

Tworzenie plików PSD indeksowanych

API Aspose.PSD dla .NET może tworzyć pliki PSD indeksowane od podstaw. Ten artykuł demonstruje użycie klas PsdOptions i PsdImage do stworzenia pliku PSD indeksowanego, rysując jednocześnie niektóre kształty na nowo utworzonej płótnie. Następujące proste kroki są wymagane do stworzenia pliku PSD indeksowanego:

• Utwórz instancję PsdOptions i ustaw na niej źródło.
• Ustaw właściwość ColorMode PsdOptions na ColorModes.Indexed.
• Utwórz nową paletę kolorów przestrzeni RGB i ustaw ją jako właściwość Palette PsdOptions.
• Ustaw właściwość CompressionMethod na żądany algorytm kompresji.
• Utwórz nowy obraz PSD, wywołując metodę PsdImage.Create.
• Narysuj grafikę lub wykonaj inne operacje zgodnie z wymaganiami.
• Wywołaj metodę PsdImage.Save, aby zatwierdzić wszystkie zmiany.

Poniższy fragment kodu pokazuje, jak tworzyć pliki PSD indeksowane.

// 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 it's properties
var createOptions = new PsdOptions();
createOptions.Source = new FileCreateSource(dataDir + "Newsample_out.psd", false);
createOptions.ColorMode = ColorModes.Indexed;
createOptions.Version = 5;

// Create a new color palette having RGB colors, Set Palette property & compression method
Color[] palette = { Color.Red, Color.Green, Color.Blue, Color.Yellow };
createOptions.Palette = new PsdColorPalette(palette);
createOptions.CompressionMethod = CompressionMethod.RLE;

// Create a new PSD with PsdOptions created previously
using (var psd = Image.Create(createOptions, 500, 500))
{
    // Draw some graphics over the newly created PSD
    var graphics = new Graphics(psd);
    graphics.Clear(Color.White);
    graphics.DrawEllipse(new Pen(Color.Red, 6), new Rectangle(0, 0, 400, 400));
    psd.Save();
}

Eksportowanie warstwy PSD do obrazu rastrowego

Aspose.PSD dla .NET pozwala eksportować warstwy w pliku PSD do obrazów rastrowych. Proszę użyć metody Aspose.PSD.FileFormats.Psd.Layers.Layer.Save do wyeksportowania warstwy do obrazu. Poniższy przykładowy kod wczytuje plik PSD i eksportuje każdą z jego warstw do obrazu PNG, używając metody Aspose.PSD.FileFormats.Psd.Layers.Layer.Save. Po wyeksportowaniu wszystkich warstw do obrazów PNG, można je otworzyć przy użyciu ulubionego przeglądarki obrazów. Poniższy fragment kodu pokazuje, jak eksportować warstwę PSD do obrazu rastrowego.

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

// Load a PSD file as an image and caste it into PsdImage
using (PsdImage psdImage = (PsdImage)Image.Load(dataDir + "sample.psd"))
{
    // Create an instance of PngOptions class
    var pngOptions = new PngOptions();
    pngOptions.ColorType = PngColorType.TruecolorWithAlpha;

    // Loop through the list of layers
    for (int i = 0; i < psdImage.Layers.Length; i++)
    {
        // Convert and save the layer to PNG file format.
        psdImage.Layers[i].Save(string.Format("layer_out{0}.png", i + 1), pngOptions);
    }
}

Aktualizacja warstwy tekstowej w pliku PSD

Aspose.PSD dla .NET pozwala manipulować tekstem w warstwie tekstowej pliku PSD. Proszę użyć klasy Aspose.PSD.FileFormats.Psd.Layers.TextLayer, aby zaktualizować tekst na warstwie PSD. Poniższy fragment kodu wczytuje plik PSD, uzyskuje dostęp do warstwy tekstowej, aktualizuje tekst i zapisuje plik PSD pod nową nazwą, używając metody Aspose.PSD.FileFormats.Psd.Layers.TextLayer.UpdateText.

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

// Load a PSD file as an image and cast it into PsdImage
using (PsdImage psdImage = (PsdImage)Image.Load(dataDir + "layers.psd"))
{
    foreach (var layer in psdImage.Layers)
    {
        if (layer is TextLayer)
        {
            TextLayer textLayer = layer as TextLayer;
            textLayer.UpdateText("test update", new Point(0, 0), 15.0f, Color.Purple);
        }
    }

    psdImage.Save(dataDir + "UpdateTextLayerInPSDFile_out.psd");
}

Wykrywanie spłaszczonego pliku PSD

Aspose.PSD dla .NET pozwala określić, czy dany plik PSD jest spłaszczony czy nie. W tym celu właściwość IsFlatten została wprowadzona w klasie Aspose.PSD.FileFormats.Psd.PsdImage. Poniższy fragment kodu wczytuje plik PSD i uzyskuje dostęp do właściwości IsFlatten.

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

// Load a PSD file as an image and cast it into PsdImage
using (PsdImage psdImage = (PsdImage)Image.Load(dataDir + "layers.psd"))
{
    // Do processing, Get the true value if PSD is flatten and false in case the PSD is not flatten.
    Console.WriteLine(psdImage.IsFlatten);
}

Łączenie warstw PSD

Ten artykuł pokazuje, jak łączyć warstwy w pliku PSD podczas konwertowania pliku PSD na JPG za pomocą Aspose.PSD. W poniższym przykładzie istniejący plik PSD jest wczytywany, przekazując ścieżkę pliku do statycznej metody Load klasy Image. Gdy zostanie wczytany, przekształć/wrzuc obraz do klasy PsdImage. Utwórz instancję klasy JpegOptions i ustaw różne właściwości. Następnie wywołaj metodę Save instancji PsdImage. Poniższy fragment kodu pokazuje, jak łączyć warstwy PSD.

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

// Load a PSD file as an image and cast it into PsdImage
using (PsdImage psdImage = (PsdImage)Image.Load(dataDir + "layers.psd"))
{
    // Create JPEG option class object, Set its properties and save image
    var jpgOptions = new JpegOptions();
    psdImage.Save(dataDir + "MergePSDlayers_output.jpg", jpgOptions);
}

Wsparcie dla odcieni szarości z alfą dla plików PSD

Ten artykuł pokazuje, jak wspierać odcienie szarości z alfą dla pliku PSD podczas konwertowania pliku PSD do PNG za pomocą Aspose.PSD. W poniższym przykładzie istniejący plik PSD jest wczytywany, przekazując ścieżkę pliku do statycznej metody Load klasy Image. Gdy zostanie wczytany, przekształć/wrzuc obraz do klasy PsdImage. Utwórz instancję klasy PngOptions i ustaw na niej różne właściwości. Ustaw właściwość ColorType na TruecolorWithAlpha. Następnie wywołaj metodę Save instancji PngOptions. Poniższy fragment kodu pokazuje, jak konwertować do odcieni szarości PNG z alfą.

Wsparcie dla efektów warstwy dla plików PSD

Ten artykuł pokazuje, jak wspierać różne efekty jak Rozmycie, Wewnętrzne słabości, Zewnętrzne słabości dla warstwy PSD. Poniższy fragment kodu pokazuje, jak wspierać efekty warstwy.

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

string sourceFileName = dataDir + "layers.psd";
string output = dataDir + "layers.png";

using (PsdImage image = (PsdImage)Image.Load(sourceFileName,
    new ImageLoadOptions.PsdLoadOptions()
    {
        LoadEffectsResource = true,
        UseDiskForLoadEffectsResource = true
    }))
{
    Debug.Assert(image.Layers[2] != null, "Layer with effects resource was not recognized");

    image.Save(output, new ImageOptions.PngOptions()
    {
        ColorType =
            FileFormats.Png
                .PngColorType
                .TruecolorWithAlpha
    });
}

Wsparcie dla daty i godziny utworzenia warstwy

Ten artykuł pokazuje, jak wspierać datę i godzinę utworzenia warstwy dla warstwy PSD. Poniższy fragment kodu pokazuje, jak tworzyć warstwy.

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

string SourceName = dataDir + "OneLayer.psd";

// Load a PSD file as an image and cast it into PsdImage
using (var im = (PsdImage)(Image.Load(SourceName)))
{
    var layer = im.Layers[0];
    var creationDateTime = layer.LayerCreationDateTime;
    var expectedDateTime = new DateTime(2018, 7, 17, 8, 57, 24, 769);

    if (expectedDateTime != creationDateTime)
    {
        throw new Exception("Assertion fails");
    }

    var now = DateTime.Now;
    var createdLayer = im.AddLevelsAdjustmentLayer();

    // Check if Creation Date Time Updated on newly created layers
    if (!(now <= createdLayer.LayerCreationDateTime))
    {
        throw new Exception("Assertion fails");
    }
}

Wsparcie dla podświetlania kolorów w arkuszu

Ten artykuł pokazuje, jak wczytać obrazy PSD, a następnie zmienić i podświetlić kolory arkuszy i zapisać je jako obraz. Fragment kodu został dostarczony.

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

string exportPath = dataDir + "SheetColorHighlightExampleChanged.psd";

// Load a PSD file as an image and cast it into PsdImage
using (var im = (PsdImage)(Image.Load(sourceFileName)))
{
    var layer1 = im.Layers[0];
    var layer2 = im.Layers[1];

    if (layer1.SheetColorHighlight != SheetColorHighlightEnum.Violet ||
        layer2.SheetColorHighlight != SheetColorHighlightEnum.Orange)
    {
        throw new Exception("Assertion failed");
    }

    layer1.SheetColorHighlight = SheetColorHighlightEnum.Yellow;

    im.Save(exportPath);
}

Wsparcie dla maski warstwy

Ten artykuł pokazuje, jak wspierać maski warstwowe dla obrazów PSD i zapisywać te obrazy. Fragment kodu został dostarczony poniżej.

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

// Export of the psd with complex mask
string sourceFileName = dataDir + "MaskComplex.psd";
string exportPath = dataDir + "MaskComplex.png";

using (var im = (PsdImage)Image.Load(sourceFileName))
{
    // Export to PNG
    var saveOptions = new PngOptions();
    saveOptions.ColorType = PngColorType.TruecolorWithAlpha;
    im.Save(exportPath, saveOptions);
}

Wsparcie dla maski warstw wektorowych

Ten artykuł pokazuje wsparcie dla maski wektorowej warstw dla Aspose.PSD. Poniższy fragment kodu pokazuje, jak Aspose.PSD obsługuje maski warstw wektorowych.

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

string exportPath = dataDir + "DifferentLayerMasks_Export.psd";
string exportPathPng = dataDir + "DifferentLayerMasks_Export.png";
// reading
using (PsdImage image = (PsdImage)Image.Load(sourceFileName))
{
    // make changes to the vector path points
    foreach (var layer in image.Layers)
    {
        foreach (var layerResource in layer.Resources)
        {
            var resource = layerResource as VectorPathDataResource;
            if (resource != null)
            {
                foreach (var pathRecord in resource.Paths)
                {
                    var bezierKnotRecord = pathRecord as BezierKnotRecord;
                    if (bezierKnotRecord != null)
                    {
                        Point p0 = bezierKnotRecord.Points[0];
                        bezierKnotRecord.Points[0] = bezierKnotRecord.Points[2];
                        bezierKnotRecord.Points[2] = p0;
                        break;
                    }
                }
            }
        }
    }
    // exporting
    image.Save(exportPath);
    image.Save(exportPathPng, new PngOptions() { ColorType = PngColorType.TruecolorWithAlpha });
}

Wsparcie dla warstw tekstowych w czasie rzeczywistym

Ten artykuł pokazuje, jak dodawać warstwy tekstowe w czasie rzeczywistym dla obrazów PSD. Fragment kodu został dostarczony poniżej.

{{