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; }एक मान प्राप्त या सेट करता है जो इंगित करता है कि क्या यह उदाहरण ताना शैली कस्टम है। यदि सही है तो इसमें जाल बिंदु शामिल हैं। अगर असत्य पर सेट किया जाता है तो यह जाली बिंदुओं को मिटा देता है.
virtual Items { get; set; }ताना आइटम प्राप्त या सेट करता है।
override Key { get; }पीएलडी संसाधन कुंजी प्राप्त करता है।
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; }पीएलडी संसाधन के लिए आवश्यक न्यूनतम पीएसडी संस्करण प्राप्त करता है। 0 कोई प्रतिबंध नहीं दर्शाता है।
Right { get; set; }PSD फ़ाइल में रखी गई परत का सही स्थान प्राप्त या सेट करता है।
override Signature { get; }पीएलडी संसाधन हस्ताक्षर प्राप्त करता है।
Top { get; set; }PSD छवि में रखी परत के शीर्ष स्थान को प्राप्त या सेट करता है।
virtual TotalPages { get; set; }PSD फ़ाइल में रखी गई परत के कुल पृष्ठों को प्राप्त या सेट करता है।
virtual TransformMatrix { get; set; }PSD फ़ाइल में रखी गई परत के ट्रांसफ़ॉर्म मैट्रिक्स को प्राप्त या सेट करता है।
virtual UniqueId { get; set; }PSD छवि में रखी गई परत का वैश्विक अद्वितीय पहचानकर्ता प्राप्त या सेट करता है।
UOrder { get; set; }PSD फ़ाइल में रखी गई परत का यू ऑर्डर मान प्राप्त या सेट करता है।
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® द्वारा अपठनीय हो सकती है
                ////resource.UOrder = 6;
                ////संसाधन। VOrder = 9;

                // इसे कोई परिवर्तन न करें अन्यथा आप निःशुल्क रूपांतरण का उपयोग नहीं कर पाएंगे
                // या अंडरलाइनिंग स्मार्ट ऑब्जेक्ट को वेक्टर प्रकार में बदलें
                ////resource.PlacedLayerType = PlacedLayerType.Vector;

                // इस विशिष्ट आईडी के साथ मान्य PlLdResource होना चाहिए
                ////resource.UniqueId = नया गाइड ("98765432-10fe-cba0-1234-56789abcdef0");

                break;
            }
        }
    }

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

यह सभी देखें

Class PhflResourceVersion3 Enum PlacedLayerType