Bearbeiten von Rastermasken in einer PSD-Datei über die API

Überblick

Um die Bearbeitung im PSD-Format zu automatisieren und eine PSD-Datei ohne Adobe® Photoshop® zu ändern, können Sie die unten bereitgestellte Aspose.PSD-API verwenden. Es gibt C# und .NET-Code-Schnipsel, die Ihnen helfen können, PSD-Dateien zu bearbeiten.

Mithilfe von PSD-Layer- und Vektormasken können wir Layer-Pixel verbergen und anzeigen, ohne sie dauerhaft zu löschen. Rastermasken werden auch als Ebenenmaske oder Nutzermaske bezeichnet. Der Zugriff auf Raster- und Vektormasken in Aspose.PSD erfolgt über die LayerMaskData-Ebeneneigenschaft, die eine Instanz der Klassen ‘LayerMaskDataShort’ und ‘LayerMaskDataFull’ sein kann, die Unterklassen der abstrakten Klasse ‘LayerMaskData’ sind. Wenn eine Ebene sowohl Raster- als auch Vektormasken hat, wird eine Instanz von LayerMaskDataFull bereitgestellt. Wenn eine Ebene nur eine Raster- oder eine Vektormaske hat, wird eine LayerMaskDataShort-Instanz bereitgestellt. Wenn die LayerMaskData-Eigenschaft null ist, hat die Ebene keine Masken oder nur eine deaktivierte Vektormaske.

	Ein Rastermaske und eine deaktivierte Vektormaske LayerMaskDataShort Eine deaktivierte Rastermaske LayerMaskDataShort Ein Rastermaske und eine Vektormaske LayerMaskDataFull Ein Rastermaske LayerMaskDataShort Eine Vektormaske LayerMaskDataShort Eine deaktivierte Vektormaske null (Aber Vektorressource ist vorhanden)

Wie man eine Rastermaske einer Ebene in der PSD-Datei abruft?

Zunächst sollten wir herausfinden, ob eine Ebene sowohl Vektor- als auch Ebenenmasken hat:

Der unten bereitgestellte Beispielcode zeigt, wie man eine Rastermaske einer Ebene abruft

LayerMaskDataFull fullMask = layer.LayerMaskData as LayerMaskDataFull;
if (fullMask != null)
{
    var left = fullMask.EnclosingLeft;
    var right = fullMask.EnclosingRight;
    var top = fullMask.EnclosingTop;
    var bottom = fullMask.EnclosingBottom;
    var maskRectangle = fullMask.UserMaskRectangle;
    var imageData = fullMask.UserMaskData;
    var defaultColor = fullMask.BackgroundColor;
    var flags = fullMask.RealFlags;
    bool isDisabled = (flags & LayerMaskFlags.Disabled) != 0;
}

Andernfalls ist der Typ der LayerMaskData-Ebeneneigenschaft LayerMaskDataShort. In diesem Fall prüfen wir, ob die Ebene nur eine Rastermaske hat, indem wir die Flags-Eigenschaft überprüfen. Sie sollte nicht die LayerMaskFlags.UserMaskFromRenderingOtherData-Flag enthalten, andernfalls handelt es sich um einen Vektormaskenspeicher.

Ausschnitt des Maskencodes abrufen:

LayerMaskDataShort mask = (LayerMaskDataShort)layer.LayerMaskData;
if ((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) == 0)
{
    var left = fullMask.Left;
    var right = fullMask.Right;
    var top = fullMask.Top;
    var bottom = fullMask.Bottom;
    var maskRectangle = mask.MaskRectangle;
    var imageData = mask.ImageData;
    var defaultColor = newMask.DefaultColor;
    var flags = newMask.Flags;
    bool isDisabled = (flags & LayerMaskFlags.Disabled) != 0;
}

Wenn Sie eine Rastermaske extrahieren müssen als LayerMaskDataShort (für weitere Manipulationen), auch wenn beide Masken vorhanden sind, sollte LayerMaskDataFull extrahiert und in LayerMaskDataShort konvertiert werden. Der folgende Code kann für beide Fälle verwendet werden:

Extrahieren einer Rastermaske aus PSD

LayerMaskDataShort GetRasterMask(LayerMaskData mask)
    {
        LayerMaskDataFull fullMask = mask as LayerMaskDataFull;
        if (mask == null ||
((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0 && fullMask == null))
        {
            return null;
        }

        if (fullMask != null)
        {
            return new LayerMaskDataShort()
            {
                Left = fullMask.EnclosingLeft,
                Right = fullMask.EnclosingRight,
                Top = fullMask.EnclosingTop,
                Bottom = fullMask.EnclosingBottom,
                ImageData = fullMask.UserMaskData,
                DefaultColor = fullMask.DefaultColor,
                Flags = fullMask.RealFlags
            };
        }

Wie man überprüft, ob eine Ebene in der PSD-Datei eine Rastermaske hat?

Der folgende C#-Code kann Ihnen dabei helfen zu überprüfen, ob eine Ebene eine Rastermaske hat:

Wie man prüft, ob eine Rastermaske auf die PSD Ebene angewendet wird

bool HasLayerRasterMask(Layer layer)
{
        var mask = layer.LayerMaskData;
        var fullMask = mask as LayerMaskDataFull;
        if (mask == null || 
   ((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0 && fullMask == null))
        {
            return false;
        }

        return true;
}

Wie man eine Rastermaske einer Ebene in der PSD-Datei entfernt/hinzufügt/aktualisiert?

Das Entfernen/Hinzufügen/Aktualisieren des LayerMaskData reicht für das korrekte Speichern nicht aus, da die Kanäle nicht aktualisiert werden; obwohl es eine korrekte Wiedergabe ermöglichen kann. Dies ändert nicht die Maskenkanäle:

layer.LayerMaskData = newMaskData;

Wir sollten die Methode AddLayerMask der Ebene für das Entfernen/Hinzufügen/Aktualisieren verwenden.

Dies fügt/aktualisiert sowohl die Maske als auch die Kanäle:

layer.AddLayerMask(newMaskData);

Dies entfernt sowohl die Maske als auch die Kanäle:

layer.AddLayerMask(null);

Entfernen einer Rastermaske einer Ebene im PSD-Bild

Zunächst überprüfen wir, ob die Maske im Kurzformat vorliegt und wenn es keine Vektormaske ist, können wir einfach die AddLayerMask-Methode mit null aufrufen, um die Rastermaske zu löschen. Ist sie jedoch im Vollformat, müssen wir sie in ein Kurzformat konvertieren und so nur die Vektormaske übrig lassen. Für das Entfernen einer Maskierung kann der folgende C# .NET-Code-Schnipsel verwendet werden:

Codeschnipsel zum Entfernen einer Maskierung von einer PSD-Datei

void RemoveRasterMask(Layer layer)
    {
        LayerMaskData mask = layer.LayerMaskData;
        LayerMaskDataFull fullMask = mask as LayerMaskDataFull;
        if (mask == null ||
((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0 && fullMask == null))
        {
            throw new Exception("This layer has no raster mask.");
        }

        if (fullMask == null)
        {
            layer.AddLayerMask(null);
            return;
        }

        var vectorMask = new LayerMaskDataShort();
        vectorMask.Flags = fullMask.Flags;
        vectorMask.MaskRectangle = fullMask.MaskRectangle;
        vectorMask.DefaultColor = fullMask.DefaultColor;
        vectorMask.ImageData = fullMask.ImageData;
        layer.AddLayerMask(vectorMask);
    }

Aktualisieren einer Rastermaske einer Ebene im PSD-Bild

Dies ist unkompliziert: wenn die Maske im Kurzformat vorliegt, müssen wir ImageData und MaskRectangle gegebenenfalls ändern, andernfalls sollten UserMaskData und UserMaskRectangle geändert werden. Der folgende C# .NET-Code-Schnipsel kann zum Aktualisieren einer Maskierung verwendet werden:

PSD-Layer-Maske mit C# aktualisieren

void RemoveRasterMask(Layer layer)
    {
        LayerMaskData mask = layer.LayerMaskData;
        LayerMaskDataFull fullMask = mask as LayerMaskDataFull;
        if (mask == null ||
((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0 && fullMask == null))
        {
            throw new Exception("This layer has no raster mask.");
        }

        if (fullMask == null)
        {
            layer.AddLayerMask(null);
            return;
        }

        var vectorMask = new LayerMaskDataShort();
        vectorMask.Flags = fullMask.Flags;
        vectorMask.MaskRectangle = fullMask.MaskRectangle;
        vectorMask.DefaultColor = fullMask.DefaultColor;
        vectorMask.ImageData = fullMask.ImageData;
        layer.AddLayerMask(vectorMask);
    }

Hier ist ein Beispiel für mögliche Aktionen, die eine Rastermaske ändern. Diese invertiert z.B. eine Benutzermaske der Ebene:

PSD-Layer-Maske mit C# aktualisieren

        void InvertMask(LayerMaskData mask)
        {
            byte[] maskBytes;
            LayerMaskDataFull fullMask = mask as LayerMaskDataFull;
            if (fullMask == null)
            {
                maskBytes = mask.ImageData;
            }
            else
            {
                maskBytes = fullMask.UserMaskData;
            }

            for (int i = 0; i < maskBytes.Length; i++)
            {
                maskBytes[i] = (byte)~maskBytes[i];
            }
        }

Aktualisieren einer Vektormaske in der PSD-Datei, wenn eine Rastermaske einer Ebene vorhanden ist

Es wird angenommen, dass ein Benutzer bereits eine Vektorpfadressource geändert hat. Dann kann er die Vektormaske einfach aktualisieren, indem er die AddLayerMask-Layermethode aufruft:

Aktualisieren von PSD Layer Vector Mask mit C#

void UpdateVectorMask(Layer layer)
    {
        var vectorMask = layer.LayerMaskData;
        if (vectorMask == null || (vectorMask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) == 0)
        {
            throw new Exception("This layer has no vector mask.");
        }

        layer.AddLayerMask(vectorMask);
    }

Hinzufügen einer Rastermaske zu einer Ebene in der PSD-Datei

Wenn eine Ebene keine Maske hat, können wir die angegebene Rastermaske einfach hinzufügen, indem wir die AddLayerMask-Layermethode aufrufen.

Wenn die Maske keine [UserMaskFromRenderingOtherData]-Flag enthält, hat sie bereits eine Rastermaske und wir müssen sie wie oben beschrieben aktualisieren. Andernfalls, wenn diese Maske im Kurzformat vorliegt, konvertieren wir sie in das Vollformat. Andernfalls verwenden wir sie wie sie ist. Dann aktualisieren Sie UserMaskData, UserMaskRectangle und andere Eigenschaften mit den angegebenen Masken-Eigenschaften. Der folgende C# .NET-Code-Schnipsel kann zum Hinzufügen (Aktualisieren) einer Maskierung verwendet werden:

Neue Rastermaske zu PSD hinzufügen

void AddRasterMask(LayerMaskData mask, LayerMaskDataShort newShortMask)
    {
        LayerMaskData mask = layer.LayerMaskData;
        LayerMaskDataFull fullMask = mask as LayerMaskDataFull;
        var hasRasterMask = fullMask != null ||
        (mask != null && (mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) == 0);

        if (hasRasterMask)
        {
            Console.WriteLine("This layer has a raster mask already, updating.");
        }

        if (mask != null)
        {
            if (fullMask != null)
            {
                // let's update user raster mask in a full one.
                fullMask.RealFlags = newMask.Flags;
                fullMask.DefaultColor = newMask.DefaultColor;
                fullMask.UserMaskRectangle = newMask.MaskRectangle;
                fullMask.UserMaskData = newMask.ImageData;
                newMask = fullMask;
            }
            else if ((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0)
            {
                // let's convert the short raster mask to a full one.
                fullMask = new LayerMaskDataFull();
                fullMask.Flags = mask.Flags;
                fullMask.MaskRectangle = mask.MaskRectangle;
                fullMask.ImageData = mask.ImageData;
                fullMask.RealFlags = newMask.Flags;
                fullMask.DefaultColor = newMask.DefaultColor;
                fullMask.UserMaskRectangle = newMask.MaskRectangle;
                fullMask.UserMaskData = newMask.ImageData;
                newMask = fullMask;
            }
        }

        // Adds or updates a mask
        layer.AddLayerMask(newMask);
    }

Wie man überprüft, ob eine Ebenenmaske aktiviert ist?

Um den Zustand der aktivierten Ebenenrastermaske herauszufinden, können wir den LayerMaskFlags.Disabled-Flag-Zustand in der Flags-Eigenschaft für LayerMaskDataShort oder in den RealFlags für LayerMaskDataFull überprüfen. Der folgende C# .NET-Code-Schnipsel kann zum Abrufen des aktivierten Zustands einer Ebenenmaske verwendet werden:

Überprüfen, ob eine Maske aktiviert ist:

bool GetRasterMaskState(Layer layer)
            {
                var mask = layer.LayerMaskData;
                var fullMask = mask as LayerMaskDataFull;
                if (mask == null || ((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0 &&
                                     fullMask == null))
                {
                    throw new Exception("This layer has no raster mask.");
                }

                if (fullMask != null)
                {
                    return (fullMask.RealFlags & LayerMaskFlags.Disabled) == 0;
                }
                else
                {
                    return (mask.Flags & LayerMaskFlags.Disabled) == 0;
                }
            }

Aktivieren oder Deaktivieren einer Rasterlayemaske?

Um eine Ebenenrastermaske zu aktivieren oder zu deaktivieren, können wir den Zustand des LayerMaskFlags.Disabled-Flags in der Flags-Eigenschaft für LayerMaskDataShort oder in den RealFlags für LayerMaskDataFull ändern. Der folgende C# .NET-Code-Schnipsel kann zum Ändern des aktivierten Zustands einer Ebenenmaske verwendet werden:

Raster-Layemaske aktivieren oder deaktivieren:

void SetRasterMaskState(Layer layer, bool isEnabled)
            {
                var mask = layer.LayerMaskData;
                var fullMask = mask as LayerMaskDataFull;
                if (mask == null || ((mask.Flags & LayerMaskFlags.UserMaskFromRenderingOtherData) != 0 &&
                                     fullMask == null))
                {
                    throw new Exception("This layer has no raster mask."));
                }

                if (fullMask != null)
                {
                    if (isEnabled)
                    {
                        fullMask.RealFlags = fullMask.RealFlags & ~LayerMaskFlags.Disabled;
                    }
                    else
                    {
                        fullMask.RealFlags = fullMask.RealFlags | LayerMaskFlags.Disabled;
                    }
                }
                else
                {
                    {
                        if (isEnabled)
                        {
                            mask.Flags = mask.Flags & ~LayerMaskFlags.Disabled;
                        }
                        else
                        {
                            mask.Flags = mask.Flags | LayerMaskFlags.Disabled;
                        }
                    }
                }
            }