Class PlacedResource

PlacedResource class

Menentukan kelas PlacedResource yang berisi informasi umum tentang lapisan yang ditempatkan atau lapisan objek pintar di file PSD. Digunakan untuk mendukung lapisan objek pintar di gambar Adobe® Photoshop®.

public abstract class PlacedResource : LayerResource, IPlacedLayerResource

Properti

NamaKeterangan
virtual AntiAliasPolicy { get; set; }Mendapat atau menyetel kebijakan anti alias dari lapisan yang ditempatkan di gambar PSD.
Bottom { get; set; }Mendapat atau menyetel lokasi bawah dari lapisan yang ditempatkan di gambar PSD.
Bounds { get; set; }Mendapat atau menyetel batas lapisan yang ditempatkan di file PSD.
HorizontalMeshPoints { get; set; }Mendapat atau menyetel titik jaring horizontal dari lapisan yang ditempatkan di file PSD.
HorizontalMeshPointUnit { get; set; }Mendapat atau menetapkan satuan ukuran dari titik jaring horizontal.
IsCustom { get; set; }Mendapat atau menetapkan nilai yang menunjukkan apakah gaya warp instance ini adalah custom. Jika true, gaya ini berisi poin mesh. Jika disetel ke false, itu akan menghapus poin mesh.
virtual Items { get; set; }Mendapat atau mengatur item warp.
abstract Key { get; }Mendapat kunci sumber daya lapisan.
Left { get; set; }Mendapat atau menyetel lokasi kiri dari lapisan yang ditempatkan di file PSD.
abstract Length { get; }Mendapatkan panjang sumber daya lapisan dalam byte.
virtual PageNumber { get; set; }Mendapat atau menyetel nomor halaman dari lapisan yang ditempatkan di file PSD.
Perspective { get; set; }Mendapat atau menyetel nilai perspektif dari lapisan yang ditempatkan di file PSD.
PerspectiveOther { get; set; }Mendapat atau menyetel nilai perspektif lain dari lapisan yang ditempatkan di file PSD.
virtual PlacedLayerType { get; set; }Mendapat atau menyetel jenis lapisan yang ditempatkan di file PSD.
abstract PsdVersion { get; }Mendapatkan versi psd minimal yang diperlukan untuk sumber daya lapisan. 0 menunjukkan tidak ada batasan.
Right { get; set; }Mendapatkan atau menyetel lokasi yang tepat dari lapisan yang ditempatkan di file PSD.
override Signature { get; }Mendapat tanda tangan sumber daya Ditempatkan.
Top { get; set; }Mendapat atau menyetel lokasi teratas dari lapisan yang ditempatkan di gambar PSD.
virtual TotalPages { get; set; }Mendapat atau menyetel total halaman dari lapisan yang ditempatkan di file PSD.
virtual TransformMatrix { get; set; }Mendapat atau menyetel matriks transformasi dari lapisan yang ditempatkan di file PSD.
virtual UniqueId { get; set; }Mendapat atau menyetel pengidentifikasi unik global dari lapisan yang ditempatkan di gambar PSD.
UOrder { get; set; }Mendapat atau menyetel nilai urutan U dari lapisan yang ditempatkan di file PSD.
Value { get; set; }Mendapat atau menyetel nilai warp dari lapisan yang ditempatkan di gambar PSD.
Version { get; }Mendapat versi lapisan yang ditempatkan di file PSD, biasanya 3.
VerticalMeshPoints { get; set; }Mendapat atau menyetel titik jaring horizontal dari lapisan yang ditempatkan di file PSD.
VerticalMeshPointUnit { get; set; }Mendapat atau menetapkan satuan ukuran dari titik jaring vertikal.
VOrder { get; set; }Mendapat atau menyetel nilai urutan V dari lapisan yang ditempatkan di file PSD.

Metode

NamaKeterangan
abstract Save(StreamContainer, int)Menyimpan sumber daya ke wadah aliran yang ditentukan.
override ToString()Mengembalikan aString yang mewakili instance ini.

Contoh

Kode berikut menunjukkan dukungan sumber daya SoLEResource, SmartObjectResource, dan 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)
{
    // Nilai ini tidak kita ubah di sumber daya
    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;

    // Nilai ini juga harus diubah di PlLdResource (dengan UniqueId yang ditentukan).
    // dan beberapa di antaranya harus sesuai dengan objek pintar yang digarisbawahi di 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];

    // Id unik ini harus diubah dalam referensi jika ada
    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];
    }

    // Berhati-hatilah dengan beberapa parameter: gambar yang disimpan mungkin tidak dapat dibaca oleh Adobe® Photoshop®
    ////resource.UOrder = 6;
    ////resource.VOrder = 9;

    // Jangan ubah ini jika tidak, Anda tidak akan dapat menggunakan transformasi bebas
    // atau ubah smart object yang digarisbawahi menjadi tipe vektor
    ////resource.PlacedLayerType = PlacedLayerType.Vector;

    // Harus ada PlLdResource yang valid dengan ID unik ini
    ////resource.UniqueId = new Guid("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;
                }
            }
        }
    }
}

Lihat juga