Edição de máscaras de camada raster em arquivo PSD via API

Visão geral

Para automatizar a edição de formatos PSD e alterar arquivos PSD sem o Adobe® Photoshop®, você pode usar a API Aspose.PSD fornecida abaixo. Existem trechos de código em C# e .NET que podem ajudá-lo a modificar arquivos PSD.

Usando Máscaras de Camada e Vetor PSD, somos capazes de ocultar e mostrar pixels de camada sem excluí-los permanentemente. Máscaras raster também são chamadas de máscara de camada ou máscara de usuário. O acesso às máscaras raster e vetor no Aspose.PSD é fornecido por meio da propriedade de camada LayerMaskData, que pode ser uma instância das classes ‘LayerMaskDataShort’ e ‘LayerMaskDataFull’ que são subclasses abstratas da classe ‘LayerMaskData’. Se uma camada tem tanto máscaras raster quanto vetor, então é fornecida uma instância de LayerMaskDataFull. Se uma camada tem apenas uma máscara raster ou vetor, então é fornecida uma instância de LayerMaskDataShort. Se a propriedade LayerMaskData for nula, então a camada não tem máscaras ou apenas uma máscara vetor desativada.

	Uma máscara raster e uma máscara de vetor desativada LayerMaskDataShort Uma máscara raster desativada LayerMaskDataShort Uma máscara raster e uma máscara vetor LayerMaskDataFull Uma máscara raster LayerMaskDataShort Uma máscara vetor LayerMaskDataShort Uma máscara de vetor desativada nula (Mas recurso de vetor está presente)

Como obter uma máscara raster de camada no arquivo PSD?

Primeiramente, devemos verificar se uma camada tem tanto máscaras de vetor quanto de camada:

O código de exemplo fornecido abaixo demonstra como obter uma máscara raster de camada

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

Caso contrário, o tipo da propriedade de camada LayerMaskData é LayerMaskDataShort. Nesse caso, vamos verificar se a camada tem apenas uma máscara raster verificando a propriedade Flags. Não deve conter o LayerMaskFlags.UserMaskFromRenderingOtherData flag, caso contrário a máscara é um cache de máscara de vetor.

Obtendo trecho de código da máscara:

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

Se você precisar extrair uma máscara raster como LayerMaskDataShort (para manipulações adicionais) mesmo quando ambas as máscaras estiverem presentes, a LayerMaskDataFull deverá ser extraída e convertida para LayerMaskDataShort. O código a seguir pode ser usado para ambos os casos:

Extraindo uma máscara raster do 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
            };
        }

Como verificar se uma camada no arquivo PSD tem uma máscara raster?

O seguinte código em C# pode ajudá-lo a verificar se uma camada tem uma máscara raster:

Como saber se a máscara raster foi aplicada à Camada PSD

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

Como remover / adicionar / atualizar uma máscara raster de camada no arquivo PSD?

Apenas remover / adicionar / atualizar o LayerMaskData não é suficiente para a correção do salvamento, pois os canais não são atualizados; embora possa fornecer uma renderização correta. Isso não altera os canais de máscara:

layer.LayerMaskData = newMaskData;

Devemos usar o método AddLayerMask da camada para remover / adicionar / atualizar.

Isso adiciona/atualiza tanto a máscara quanto os canais:

layer.AddLayerMask(newMaskData);

Isso remove tanto a máscara quanto os canais:

layer.AddLayerMask(null);

Removendo uma máscara raster de camada na imagem PSD

Primeiramente, verificamos se a máscara está no formato curto e se não é de vetor, podemos simplesmente chamar o método AddLayerMask com null para excluir a máscara raster. Mas se estiver no formato completo, precisamos convertê-la para o formato curto, deixando apenas a máscara de vetor. Para remover uma máscara de camada, o seguinte trecho de código em C# .NET pode ser usado:

Trecho de código de como remover Máscara de Camada do Arquivo PSD.

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

Atualizando uma máscara raster de camada na imagem PSD

Isso é direto: se a máscara estiver no formato curto, devemos alterar ImageData e MaskRectangle se necessário, caso contrário UserMaskData e UserMaskRectangle devem ser alterados. O seguinte trecho de código em C# .NET pode ser usado para atualizar uma máscara de camada:

Atualizar Máscara de Camada PSD com C#

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

Aqui está um exemplo de possíveis ações que alteram uma máscara raster. Este inverte uma máscara de usuário de camada:

Atualizar Máscara de Camada PSD com C#

        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];
            }
        }

Atualizando uma máscara de vetor no arquivo PSD quando uma máscara raster de camada está presente

Supõe-se que um usuário já tenha alterado um recurso de caminho de vetor. Em seguida, pode atualizar a máscara de vetor simplesmente chamando o método de camada AddLayerMask :

Atualizar Máscara de Vetor de Camada PSD com 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);
    }

Adicionando uma máscara raster de camada no arquivo PSD

Se uma camada não tem máscara, podemos adicionar a máscara raster fornecida simplesmente chamando o método de camada AddLayerMask.

Se a máscara não tem a flag UserMaskFromRenderingOtherData**, então ela já possui uma máscara raster e devemos atualizá-la conforme descrito acima. Caso contrário, se esta máscara estiver em um formato curto, a convertamos para o formato completo. Se não, a usamos como está. Em seguida, atualize UserMaskData, UserMaskRectangle e outras propriedades com as propriedades da máscara fornecida. O seguinte trecho de código em C# .NET pode ser usado para adicionar (atualizar) uma máscara de camada:

Adicionar nova Máscara de Camada ao PSD

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

Como verificar se uma máscara de camada está habilitada?

Para descobrir o estado habilitado da máscara raster da camada, podemos verificar o estado da flag LayerMaskFlags.Disabled na propriedade Flags para LayerMaskDataShort ou em RealFlags para LayerMaskDataFull. O seguinte trecho de código em C# .NET pode ser usado para obter o estado habilitado da máscara da camada:

Verificar se uma máscara está habilitada:

Como habilitar ou desabilitar uma máscara de camada raster?

Para habilitar ou desabilitar uma máscara de camada raster, podemos mudar o estado da flag LayerMaskFlags.Disabled na propriedade Flags para LayerMaskDataShort ou em RealFlags para LayerMaskDataFull. O seguinte trecho de código em C# .NET pode ser usado para alterar o estado habilitado de uma máscara de camada:

Habilitar ou desabilitar Máscara de Camada Raster:

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