Class SmartObjectResource

SmartObjectResource class

SmartObjectResource वर्ग को परिभाषित करता है जिसमें PSD फ़ाइल में स्मार्ट ऑब्जेक्ट परत के बारे में जानकारी होती है। बिकाऊ और एकमात्र संसाधनों के लिए आधार वर्ग है जिसका उपयोग Adobe® Photoshop® छवियों में स्मार्ट ऑब्जेक्ट परतों का समर्थन करने के लिए किया जाता है।

public abstract class SmartObjectResource : PlacedResource, ISmartObjectLayerResource

गुण

नाम	विवरण
override AntiAliasPolicy { get; set; }	PSD छवि में स्मार्ट ऑब्जेक्ट परत डेटा की अन्य उपनाम नीति प्राप्त या सेट करता है।
Bottom { get; set; }	PSD छवि में रखी परत के निचले स्थान को प्राप्त या सेट करता है।
Bounds { get; set; }	PSD फ़ाइल में रखी परत की सीमा प्राप्त या सेट करता है।
Comp { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा का कॉम्प वैल्यू प्राप्त या सेट करता है। स्मार्ट ऑब्जेक्ट्स में लेयर कंप्स
CompId { get; set; }	चाइल्ड दस्तावेज़ के लिए वर्तमान में चयनित COMP की आईडी प्राप्त या सेट करता है, जो -1 होगा यदि कोई भी चयनित नहीं है। Comps पृष्ठ लेआउट की रचनाएँ हैं जो डिज़ाइनर बना सकते हैं। लेयर कंप्स का उपयोग करके, आप एक ही Adobe® Photoshop® फ़ाइल में लेआउट के कई संस्करण बना, प्रबंधित और देख सकते हैं। एक परत कॉम्प परत पैनल की स्थिति का एक स्नैपशॉट है। परत कम्पास तीन प्रकार के परत विकल्पों को सहेजते हैं लेकिन यह संपत्ति PSD फ़ाइल में स्मार्ट ऑब्जेक्ट परत के लिए परत कॉम्प चयन पहचानकर्ता प्राप्त करती है। स्मार्ट ऑब्जेक्ट्स में लेयर कंप्स
Crop { get; set; }	PSD इमेज में स्मार्ट ऑब्जेक्ट लेयर डेटा का क्रॉप प्राप्त या सेट करता है।
DurationDenominator { get; set; }	अवधि भाजक प्राप्त या सेट करता है।
DurationNumerator { get; set; }	अवधि अंश प्राप्त या सेट करता है।
FrameCount { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा की फ्रेम संख्या प्राप्त या सेट करता है।
FrameStepDenominator { get; set; }	फ्रेम स्टेप डिनोमिनेटर प्राप्त या सेट करता है।
FrameStepNumerator { get; set; }	फ्रेम चरण अंश को प्राप्त या सेट करता है।
Height { get; set; }	ऊंचाई प्राप्त या सेट करता है।
HorizontalMeshPoints { get; set; }	PSD फ़ाइल में रखी गई परत के क्षैतिज जाल बिंदुओं को प्राप्त या सेट करता है।
HorizontalMeshPointUnit { get; set; }	क्षैतिज जाल बिंदुओं की माप इकाई प्राप्त या सेट करता है।
IsCustom { get; set; }	एक मान प्राप्त या सेट करता है जो इंगित करता है कि क्या यह उदाहरण ताना शैली कस्टम है। यदि सही है तो इसमें जाल बिंदु शामिल हैं। अगर असत्य पर सेट किया जाता है तो यह जाली बिंदुओं को मिटा देता है.
override Items { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा के डिस्क्रिप्टर आइटम प्राप्त या सेट करता है।
abstract Key { get; }	परत संसाधन कुंजी प्राप्त करता है.
Left { get; set; }	PSD फ़ाइल में रखी गई परत के बाएं स्थान को प्राप्त या सेट करता है।
override Length { get; }	बाइट्स में स्मार्ट ऑब्जेक्ट संसाधन लंबाई प्राप्त करता है।
NonAffineTransformMatrix { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा के नॉन एफाइन ट्रांसफ़ॉर्म मैट्रिक्स को प्राप्त या सेट करता है।
OriginalCompId { get; }	चाइल्ड दस्तावेज़ के लिए वर्तमान में चयनित कॉम्प की मूल आईडी प्राप्त करता है, जो -1 होगा यदि कोई भी चयनित नहीं है। यह संपत्ति PSD फ़ाइल में स्मार्ट ऑब्जेक्ट परत के लिए मूल परत कॉम्प चयन पहचानकर्ता प्राप्त करती है। स्मार्ट ऑब्जेक्ट्स में लेयर कंप्स
override PageNumber { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा का पेज नंबर प्राप्त या सेट करता है।
Perspective { get; set; }	PSD फ़ाइल में रखी गई परत का परिप्रेक्ष्य मान प्राप्त या सेट करता है।
PerspectiveOther { get; set; }	PSD फ़ाइल में रखी गई परत के परिप्रेक्ष्य को अन्य मान देता है या सेट करता है।
PlacedId { get; set; }	PSD इमेज में इस स्मार्ट ऑब्जेक्ट लेयर डेटा का विशिष्ट पहचानकर्ता प्राप्त या सेट करता है।
override PlacedLayerType { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा का प्रकार प्राप्त या सेट करता है।
override PsdVersion { get; }	स्मार्ट ऑब्जेक्ट संसाधन के लिए आवश्यक न्यूनतम पीएसडी संस्करण प्राप्त करता है। 0 कोई प्रतिबंध नहीं दर्शाता है।
Resolution { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा का रिज़ॉल्यूशन प्राप्त या सेट करता है।
ResolutionUnit { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा की रिज़ॉल्यूशन माप इकाई प्राप्त या सेट करता है।
Right { get; set; }	PSD फ़ाइल में रखी गई परत का सही स्थान प्राप्त या सेट करता है।
override Signature { get; }	स्मार्ट ऑब्जेक्ट संसाधन हस्ताक्षर प्राप्त करता है।
Top { get; set; }	PSD छवि में रखी परत के शीर्ष स्थान को प्राप्त या सेट करता है।
override TotalPages { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा की कुल पृष्ठ संख्या प्राप्त या सेट करता है।
override TransformMatrix { get; set; }	PSD फ़ाइल में स्मार्ट ऑब्जेक्ट लेयर डेटा के ट्रांसफ़ॉर्म मैट्रिक्स को प्राप्त या सेट करता है।
override UniqueId { get; set; }	स्मार्ट ऑब्जेक्ट लेयर डेटा का ग्लोबल यूनीक आइडेंटिफ़ायर प्राप्त या सेट करता है`SmartObjectResource` 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 क्रम मान प्राप्त या सेट करता है।
Width { get; set; }	चौड़ाई प्राप्त या सेट करता है।

तरीकों

नाम	विवरण
override Save(StreamContainer, int)	स्मार्ट ऑब्जेक्ट संसाधन को निर्दिष्ट स्ट्रीम कंटेनर में सहेजता है।
override ToString()	रिटर्न एString जो इस उदाहरण का प्रतिनिधित्व करता है।

उदाहरण

निम्न कोड SoLEResource, SmartObjectResource और PlacedResource संसाधनों के समर्थन को प्रदर्शित करता है।

[C#]

void AssertIsTrue(bool condition)
{
    if (!condition)
    {
        throw new FormatException(string.Format("Expected true"));
    }
}

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

void CheckSmartObjectResourceValues(object[] expectedValue, SmartObjectResource resource)
{
    AssertAreEqual(expectedValue[0], resource.IsCustom);
    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);

    AssertAreEqual(expectedValue[16], resource.Crop);
    AssertAreEqual(expectedValue[17], resource.FrameStepNumerator);
    AssertAreEqual(expectedValue[18], resource.FrameStepDenominator);
    AssertAreEqual(expectedValue[19], resource.DurationNumerator);
    AssertAreEqual(expectedValue[20], resource.DurationDenominator);
    AssertAreEqual(expectedValue[21], resource.FrameCount);
    AssertAreEqual(expectedValue[22], resource.Width);
    AssertAreEqual(expectedValue[23], resource.Height);
    AssertAreEqual(expectedValue[24], resource.Resolution);
    AssertAreEqual(expectedValue[25], resource.ResolutionUnit);
    AssertAreEqual(expectedValue[26], resource.Comp);
    AssertAreEqual(expectedValue[27], resource.CompId);
    AssertAreEqual(expectedValue[28], resource.OriginalCompId);
    AssertAreEqual(expectedValue[29], resource.PlacedId.ToString());
    AssertAreEqual(expectedValue[30], resource.NonAffineTransformMatrix);
    if (resource.IsCustom)
    {
        AssertAreEqual(expectedValue[31], resource.HorizontalMeshPointUnit);
        AssertAreEqual((double[])expectedValue[32], resource.HorizontalMeshPoints);
        AssertAreEqual(expectedValue[33], resource.VerticalMeshPointUnit);
        AssertAreEqual((double[])expectedValue[34], resource.VerticalMeshPoints);
    }
}

void SetNewSmartValues(SmartObjectResource resource, object[] newValues)
{
    // यह मान हम संसाधन में नहीं बदलते हैं
    newValues[0] = resource.IsCustom;
    newValues[1] = resource.UniqueId.ToString();
    newValues[5] = resource.PlacedLayerType;
    newValues[14] = resource.UOrder;
    newValues[15] = resource.VOrder;
    newValues[28] = resource.OriginalCompId;

    // यह मान PlLdResource (निर्दिष्ट UniqueId के साथ) में भी बदला जाना चाहिए
    // और उनमें से कुछ को LinkDataSource में अंडरलाइनिंग स्मार्ट ऑब्जेक्ट के अनुरूप होना चाहिए
    resource.PageNumber = (int)newValues[2]; // 2;
    resource.TotalPages = (int)newValues[3]; // 3;
    resource.AntiAliasPolicy = (int)newValues[4]; // 0;
    resource.TransformMatrix = (double[])newValues[6];
    resource.Value = (double)newValues[7]; // 1.23456789;
    resource.Perspective = (double)newValues[8]; // 0.123456789;
    resource.PerspectiveOther = (double)newValues[9]; // 0.987654321;
    resource.Top = (double)newValues[10]; // -126;
    resource.Left = (double)newValues[11]; // -215;
    resource.Bottom = (double)newValues[12]; // 248;
    resource.Right = (double)newValues[13]; // 145;
    resource.Crop = (int)newValues[16]; // 5;
    resource.FrameStepNumerator = (int)newValues[17]; // 1;
    resource.FrameStepDenominator = (int)newValues[18]; // 601;
    resource.DurationNumerator = (int)newValues[19]; // 2;
    resource.DurationDenominator = (int)newValues[20]; // 602;
    resource.FrameCount = (int)newValues[21]; // 11;
    resource.Width = (double)newValues[22]; // 541;
    resource.Height = (double)newValues[23]; // 249;
    resource.Resolution = (double)newValues[24]; // 144;
    resource.ResolutionUnit = (UnitTypes)newValues[25];
    resource.Comp = (int)newValues[26]; // 21;
    resource.CompId = (int)newValues[27]; // 22;
    resource.NonAffineTransformMatrix = (double[])newValues[30];

    // इस अनूठी आईडी को संदर्भों में बदला जाना चाहिए यदि कोई हो
    resource.PlacedId = new Guid((string)newValues[29]);  // "12345678-9abc-def0-9876-54321fecba98");
    if (resource.IsCustom)
    {
        resource.HorizontalMeshPointUnit = (UnitTypes)newValues[31];
        resource.HorizontalMeshPoints = (double[])newValues[32];
        resource.VerticalMeshPointUnit = (UnitTypes)newValues[33];
        resource.VerticalMeshPoints = (double[])newValues[34];
    }

    // कुछ मापदंडों से सावधान रहें: सहेजी गई छवि Adobe® Photoshop® द्वारा अपठनीय हो सकती है
    ////resource.UOrder = 6;
    ////संसाधन। VOrder = 9;

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

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

object[] newSmartValues = new object[]
{
    true,
    null,
    2,
    3,
    0,
    PlacedLayerType.ImageStack,
    new double[8]
    {
        12.937922786050663,
        19.419959734187131,
        2.85445817782261,
        1.0540625423957124,
        7.20861031651307,
        14.634102808208553,
        17.292074924741144,
        4
    },
    1.23456789,
    0.123456789,
    0.987654321,
    -126d,
    -215d,
    248d,
    145d,
    4,
    4,
    5,
    1,
    601,
    2,
    602,
    11,
    541d,
    249d,
    144d,
    UnitTypes.Percent,
    21,
    22,
    23,
    "12345678-9abc-def0-9876-54321fecba98",
    new double[8]
    {
        129.937922786050663,
        195.419959734187131,
        26.85445817782261,
        12.0540625423957124,
        72.20861031651307,
        147.634102808208553,
        175.292074924741144,
        42
    },
    UnitTypes.Points,
    new double[16]
    {
        0.01d, 103.33333333333433d, 206.66686666666666d, 310.02d,
        0.20d, 103.33333333333533d, 206.69666666666666d, 310.03d,
        30.06d, 103.33333333336333d, 206.66660666666666d, 310.04d,
        04.05d, 103.33333333373333d, 206.66666166666666d, 310.05d
    },
    UnitTypes.Distance,
    new double[16]
    {
        0.06d, 0.07d, 0.08d, 0.09d,
        49.066666666666664d, 49.266666666666664d, 49.566666666666664d, 49.766666666666664d,
        99.133333333333329d, 99.433333333333329d, 99.633333333333329d, 99.833333333333329d,
        140, 141, 142, 143,
    },
};

object[] expectedValues = new object[]
{
    new object[]
    {
        false,
        "5867318f-3174-9f41-abca-22f56a75247e",
        1,
        1,
        0x10,
        PlacedLayerType.Raster,
        new double[8]
        {
            0, 0, 2, 0, 2, 2, 0, 2
        },
        0d,
        0d,
        0d,
        0d,
        0d,
        2d,
        2d,
        4,
        4,
        1,
        0,
        600,
        0,
        600,
        1,
        2d,
        2d,
        72d,
        UnitTypes.Density,
        -1,
        -1,
        -1,
        "64b3997c-06e0-be40-a349-41acf397c897",
        new double[8]
        {
            0, 0, 2, 0, 2, 2, 0, 2
        },
    }
};

var sourceFilePath = "rgb8_2x2_linked.psd";
var outputPath = "rgb8_2x2_linked_output.psd";
using (PsdImage image = (PsdImage)Image.Load(sourceFilePath))
{
    SoLeResource soleResource = null;
    int index = 0;
    foreach (Layer imageLayer in image.Layers)
    {
        foreach (var imageResource in imageLayer.Resources)
        {
            var resource = imageResource as SoLeResource;
            if (resource != null)
            {
                soleResource = resource;
                var expectedValue = (object[])expectedValues[index++];
                AssertAreEqual(expectedValue[1], resource.UniqueId.ToString());
                CheckSmartObjectResourceValues(expectedValue, resource);
                SetNewSmartValues(resource, newSmartValues);

                break;
            }
        }
    }

    AssertIsTrue(soleResource != null);
    image.Save(outputPath, new PsdOptions(image));
    using (PsdImage savedImage = (PsdImage)Image.Load(outputPath))
    {
        foreach (Layer imageLayer in savedImage.Layers)
        {
            foreach (var imageResource in imageLayer.Resources)
            {
                var resource = imageResource as SoLeResource;
                if (resource != null)
                {
                    CheckSmartObjectResourceValues(newSmartValues, resource);

                    break;
                }
            }
        }
    }
}

यह सभी देखें

class SoLdResource
class SoLeResource
class PlacedResource
interface ISmartObjectLayerResource
नाम स्थान Aspose.PSD.FileFormats.Psd.Layers.LayerResources
सभा Aspose.PSD

Class ShmdResource Class SmartResourceCreator