Class PlLdResource

PlLdResource class

定义 PlLdResource 类，其中包含有关 PSD 文件中已放置层的信息。用于支持 Adobe® Photoshop® 图像中的智能对象层。在 Adobe® Photoshop® CS3 中已被 SoLdResource 取代

public class PlLdResource : PlacedResource

特性

姓名	描述
virtual AntiAliasPolicy { get; set; }	获取或设置PSD图像中放置图层的抗锯齿策略。
Bottom { get; set; }	获取或设置放置图层在PSD图像中的底部位置。
Bounds { get; set; }	获取或设置 PSD 文件中放置层的边界。
HorizontalMeshPoints { get; set; }	获取或设置放置图层在PSD文件中的水平网格点。
HorizontalMeshPointUnit { get; set; }	获取或设置水平网格点的度量单位。
IsCustom { get; set; }	获取或设置一个值，该值指示此实例扭曲样式是否为自定义。如果为真，则它包含网格点。如果设置为 false，它会擦除网格点。
virtual Items { get; set; }	获取或设置扭曲项。
override Key { get; }	获取 PlLd 资源密钥。
Left { get; set; }	获取或设置放置图层在PSD文件中的左侧位置。
override Length { get; }	获取以字节为单位的 PlLd 资源长度。
virtual PageNumber { get; set; }	获取或设置放置图层在PSD文件中的页码。
Perspective { get; set; }	获取或设置PSD文件中放置图层的透视值。
PerspectiveOther { get; set; }	获取或设置PSD文件中放置图层的透视其他值。
virtual PlacedLayerType { get; set; }	获取或设置PSD文件中放置图层的类型。
override PsdVersion { get; }	获取 PlLd 资源所需的最低 psd 版本。 0 表示没有限制。
Right { get; set; }	获取或设置放置图层在 PSD 文件中的正确位置。
override Signature { get; }	获取 PlLd 资源签名。
Top { get; set; }	获取或设置放置图层在 PSD 图像中的顶部位置。
virtual TotalPages { get; set; }	获取或设置PSD文件中放置层的总页数。
virtual TransformMatrix { get; set; }	获取或设置放置图层在PSD文件中的变换矩阵。
virtual UniqueId { get; set; }	获取或设置放置图层在PSD图像中的全局唯一标识符。
UOrder { get; set; }	获取或设置放置图层在PSD文件中的U序值。
Value { get; set; }	获取或设置PSD图像中放置层的扭曲值。
Version { get; }	获取PSD文件中放置图层的版本，通常为3.
VerticalMeshPoints { get; set; }	获取或设置放置图层在PSD文件中的水平网格点。
VerticalMeshPointUnit { get; set; }	获取或设置垂直网格点的度量单位。
VOrder { get; set; }	获取或设置放置图层在PSD文件中的V序值。

方法

姓名	描述
override Save(StreamContainer, int)	将 PlLD 资源保存到指定的流容器中。
override ToString()	返回一个String代表这个实例.

字段

姓名	描述
const TypeToolKey	类型工具信息键。

例子

以下代码演示了对 PlLdResource 资源的支持。

[C#]

void AssertAreEqual(object actual, object expected)
{
    var areEqual = object.Equals(actual, expected);
    if (!areEqual && actual is Array && expected is Array)
    {
        var actualArray = (Array)actual;
        var expectedArray = (Array)actual;
        if (actualArray.Length == expectedArray.Length)
        {
            for (int i = 0; i < actualArray.Length; i++)
            {
                if (!object.Equals(actualArray.GetValue(i), expectedArray.GetValue(i)))
                {
                    break;
                }
            }

            areEqual = true;
        }
    }

    if (!areEqual)
    {
        throw new FormatException(
            string.Format("Actual value {0} are not equal to expected {1}.", actual, expected));
    }
}

var sourceFilePath = "LayeredSmartObjects8bit2.psd";
var outputFilePath = "LayeredSmartObjects8bit2_output.psd";
var expectedValues = new object[]
{
    new object[]
    {
        true,
        "76f05a3b-7523-5e42-a1bb-27f4735bffa0",
        1,
        1,
        0x10,
        PlacedLayerType.Raster,
        new double[8]
        {
            29.937922786050663,
            95.419959734187131,
            126.85445817782261,
            1.0540625423957124,
            172.20861031651307,
            47.634102808208553,
            75.292074924741144,
            142
        },
        0d,
        0d,
        0d,
        0d,
        0d,
        149d,
        310d,
        4,
        4,
        UnitTypes.Pixels,
        new double[16]
        {
            0.0d, 103.33333333333333d, 206.66666666666666d, 310.0d,
            0.0d, 103.33333333333333d, 206.66666666666666d, 310.0d,
            0.0d, 103.33333333333333d, 206.66666666666666d, 310.0d,
            0.0d, 103.33333333333333d, 206.66666666666666d, 310.0d
        },
        UnitTypes.Pixels,
        new double[16]
        {
            0.0d, 0.0d, 0.0d, 0.0d,
            49.666666666666664d, 49.666666666666664d, 49.666666666666664d, 49.666666666666664d,
            99.333333333333329d, 99.333333333333329d, 99.333333333333329d, 99.333333333333329d,
            149, 149, 149, 149,
        },
    },
    new object[]
    {
        true,
        "cf0477a8-8f92-ac4f-9462-f78e26234851",
        1,
        1,
        0x10,
        PlacedLayerType.Raster,
        new double[8]
        {
            37.900314592235681,
            -0.32118219433001371,
            185.94210608826535,
            57.7076819802063,
            153.32047433609358,
            140.9311755779743,
            5.2786828400639294,
            82.902311403437977,
        },
        0d,
        0d,
        0d,
        0d,
        0d,
        721d,
        1280d,
        4,
        4,
        UnitTypes.Pixels,
        new double[16]
        {
            0.0, 426.66666666666663, 853.33333333333326, 1280,
            0.0, 426.66666666666663, 853.33333333333326, 1280,
            0.0, 426.66666666666663, 853.33333333333326, 1280,
            0.0, 426.66666666666663, 853.33333333333326, 1280,
        },
        UnitTypes.Pixels,
        new double[16]
        {
            0.0, 0.0, 0.0, 0.0,
            240.33333333333331, 240.33333333333331, 240.33333333333331, 240.33333333333331,
            480.66666666666663, 480.66666666666663, 480.66666666666663, 480.66666666666663,
            721, 721, 721, 721,
        },
        0,
        0
    }
};

using (PsdImage image = (PsdImage)Image.Load(sourceFilePath))
{
    PlLdResource resource = null;
    int index = 0;
    foreach (Layer imageLayer in image.Layers)
    {
        foreach (var imageResource in imageLayer.Resources)
        {
            resource = imageResource as PlLdResource;
            if (resource != null)
            {
                var expectedValue = (object[])expectedValues[index++];
                AssertAreEqual(expectedValue[0], resource.IsCustom);
                AssertAreEqual(expectedValue[1], resource.UniqueId.ToString());
                AssertAreEqual(expectedValue[2], resource.PageNumber);
                AssertAreEqual(expectedValue[3], resource.TotalPages);
                AssertAreEqual(expectedValue[4], resource.AntiAliasPolicy);
                AssertAreEqual(expectedValue[5], resource.PlacedLayerType);
                AssertAreEqual(8, resource.TransformMatrix.Length);
                AssertAreEqual((double[])expectedValue[6], resource.TransformMatrix);
                AssertAreEqual(expectedValue[7], resource.Value);
                AssertAreEqual(expectedValue[8], resource.Perspective);
                AssertAreEqual(expectedValue[9], resource.PerspectiveOther);
                AssertAreEqual(expectedValue[10], resource.Top);
                AssertAreEqual(expectedValue[11], resource.Left);
                AssertAreEqual(expectedValue[12], resource.Bottom);
                AssertAreEqual(expectedValue[13], resource.Right);
                AssertAreEqual(expectedValue[14], resource.UOrder);
                AssertAreEqual(expectedValue[15], resource.VOrder);
                if (resource.IsCustom)
                {
                    AssertAreEqual(expectedValue[16], resource.HorizontalMeshPointUnit);
                    AssertAreEqual((double[])expectedValue[17], resource.HorizontalMeshPoints);
                    AssertAreEqual(expectedValue[18], resource.VerticalMeshPointUnit);
                    AssertAreEqual((double[])expectedValue[19], resource.VerticalMeshPoints);
                    var temp = resource.VerticalMeshPoints;
                    resource.VerticalMeshPoints = resource.HorizontalMeshPoints;
                    resource.HorizontalMeshPoints = temp;
                }
                
                resource.PageNumber = 2;
                resource.TotalPages = 3;
                resource.AntiAliasPolicy = 30;
                resource.Value = 1.23456789;
                resource.Perspective = 0.123456789;
                resource.PerspectiveOther = 0.987654321;
                resource.Top = -126;
                resource.Left = -215;
                resource.Bottom = 248;
                resource.Right = 145;

                // 注意一些参数：图像可能无法被 Adobe® Photoshop® 读取
                ////资源.UOrder = 6;
                ////资源.VOrder = 9;

                // 不要改变这个，否则你将无法使用自由变换
                // 或将下划线智能对象更改为矢量类型
                ////resource.PlacedLayerType = PlacedLayerType.Vector;

                // 应该有具有此唯一 ID 的有效 PlLdResource
                ////resource.UniqueId = new Guid("98765432-10fe-cba0-1234-56789abcdef0");

                break;
            }
        }
    }

    AssertAreEqual(true, resource != null);
    image.Save(outputFilePath, new PsdOptions(image));
}

也可以看看

class PlacedResource
命名空间 Aspose.PSD.FileFormats.Psd.Layers.LayerResources
部件 Aspose.PSD

Class PhflResourceVersion3 Enum PlacedLayerType