Class SmartObjectResource

SmartObjectResource class

Definierar klassen SmartObjectResource som innehåller information om ett smart objektlager i en PSD-fil. Is är basklassen för Sold och Sole-resurser som används för att stödja smarta objektlager i Adobe® Photoshop®-bilderna.

public abstract class SmartObjectResource : PlacedResource, ISmartObjectLayerResource

Egenskaper

namn	Beskrivning
override AntiAliasPolicy { get; set; }	Hämtar eller ställer in anti-alias-policyn för data för smarta objektlager i PSD-bilden.
Bottom { get; set; }	Hämtar eller ställer in den nedre platsen för det placerade lagret i PSD-bilden.
Bounds { get; set; }	Hämtar eller ställer in gränserna för det placerade lagret i PSD-filen.
Comp { get; set; }	Hämtar eller ställer in kompvärdet för data för smarta objektlager i PSD-filen. Layer comps i Smart Objects
CompId { get; set; }	Hämtar eller ställer in ID för den för närvarande valda komp för det underordnade dokumentet, vilket kommer att vara -1 om ingen är vald. Comps är sammansättningar av en sidlayout som designers kan skapa. Med hjälp av lagersammansättningar kan du skapa, hantera och visa flera versioner av en layout i en enda Adobe® Photoshop®-fil. En lagerkomp är en ögonblicksbild av ett tillstånd på panelen Lager. Layer Comps sparar tre typer av lageralternativ men den här egenskapen får Layer Comp-urvalsidentifieraren för det smarta objektlagret i PSD-filen. Layer comps i Smart Objects
Crop { get; set; }	Hämtar eller ställer in beskärningen av data för smarta objektlager i PSD-bilden.
DurationDenominator { get; set; }	Hämtar eller ställer in varaktighetsnämnaren.
DurationNumerator { get; set; }	Hämtar eller ställer in varaktighetsräknaren.
FrameCount { get; set; }	Hämtar eller ställer in bildruteantalet för smarta objektlagerdata i PSD-filen.
FrameStepDenominator { get; set; }	Hämtar eller ställer in ramstegsnämnaren.
FrameStepNumerator { get; set; }	Hämtar eller ställer in bildstegstäljaren.
Height { get; set; }	Hämtar eller ställer in höjden.
HorizontalMeshPoints { get; set; }	Hämtar eller ställer in de horisontella mesh-punkterna för det placerade lagret i PSD-filen.
HorizontalMeshPointUnit { get; set; }	Hämtar eller ställer in måttenheten för de horisontella maskpunkterna.
IsCustom { get; set; }	Hämtar eller ställer in ett värde som indikerar om denna instansförvrängningsstil är anpassad. Om den är sant innehåller den mesh-punkter. Om den är inställd på false raderas mesh-punkter.
override Items { get; set; }	Hämtar eller ställer in deskriptorobjekten för data för smarta objektlager i PSD-filen.
abstract Key { get; }	Hämtar lagerresursnyckeln.
Left { get; set; }	Hämtar eller ställer in den vänstra platsen för det placerade lagret i PSD-filen.
override Length { get; }	Hämtar resurslängden för smarta objekt i byte.
NonAffineTransformMatrix { get; set; }	Hämtar eller ställer in den icke-affina transformationsmatrisen för data för smarta objektlager i PSD-filen.
OriginalCompId { get; }	Hämtar det ursprungliga ID:t för den för närvarande valda Comp för det underordnade dokumentet, vilket kommer att vara -1 om ingen är markerad. Den här egenskapen får den ursprungliga lager Comp-urvalsidentifieraren för det smarta objektlagret i PSD-filen. Layer comps i Smart Objects
override PageNumber { get; set; }	Hämtar eller ställer in sidnumret för data för smarta objektlager i PSD-filen.
Perspective { get; set; }	Hämtar eller ställer in perspektivvärdet för det placerade lagret i PSD-filen.
PerspectiveOther { get; set; }	Hämtar eller ställer in perspektivets andra värde för det placerade lagret i PSD-filen.
PlacedId { get; set; }	Hämtar eller ställer in den unika identifieraren för denna smarta objektlagerdata i PSD-bilden.
override PlacedLayerType { get; set; }	Hämtar eller ställer in typen av smart objektlagerdata i PSD-filen.
override PsdVersion { get; }	Får den minimala psd-version som krävs för resursen för smarta objekt. 0 indikerar inga begränsningar.
Resolution { get; set; }	Hämtar eller ställer in upplösningen för data för smarta objektlager i PSD-filen.
ResolutionUnit { get; set; }	Hämtar eller ställer in upplösningsmåttenheten för data för smarta objektlager i PSD-filen.
Right { get; set; }	Hämtar eller ställer in rätt plats för det placerade lagret i PSD-filen.
override Signature { get; }	Får resurssignaturen för smarta objekt.
Top { get; set; }	Hämtar eller ställer in den övre platsen för det placerade lagret i PSD-bilden.
override TotalPages { get; set; }	Hämtar eller ställer in det totala sidnumret för data för smarta objektlager i PSD-filen.
override TransformMatrix { get; set; }	Hämtar eller ställer in transformationsmatrisen för data för smarta objektlager i PSD-filen.
override UniqueId { get; set; }	Hämtar eller ställer in den globala unika identifieraren för data för smarta objektlagerSmartObjectResource i PSD-bilden.
UOrder { get; set; }	Hämtar eller ställer in U-ordervärdet för det placerade lagret i PSD-filen.
Value { get; set; }	Hämtar eller ställer in varpvärdet för det placerade lagret i PSD-bilden.
Version { get; }	Hämtar versionen av det placerade lagret i PSD-filen, vanligtvis 3.
VerticalMeshPoints { get; set; }	Hämtar eller ställer in de horisontella mesh-punkterna för det placerade lagret i PSD-filen.
VerticalMeshPointUnit { get; set; }	Hämtar eller ställer in måttenheten för de vertikala maskpunkterna.
VOrder { get; set; }	Hämtar eller ställer in V-ordningens värde för det placerade lagret i PSD-filen.
Width { get; set; }	Hämtar eller ställer in bredden.

Metoder

namn	Beskrivning
override Save(StreamContainer, int)	Sparar den smarta objektresursen till den angivna strömbehållaren.
override ToString()	Returnerar enString som representerar denna instans.

Exempel

Följande kod visar stödet för resurserna SoLEResource, SmartObjectResource och 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)
{
    // Dessa värden ändrar vi inte i resurs
    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;

    // Dessa värden bör också ändras i PlLdResource (med det angivna UniqueId).
    // och några av dem måste vara i överensstämmelse med det understrukna smarta objektet i 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];

    // Detta unika ID bör ändras i referenser om några
    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];
    }

    // Var försiktig med vissa parametrar: den sparade bilden kan bli oläslig av Adobe® Photoshop®
    ////resource.UOrder = 6;
    ////resource.VOrder = 9;

    // Ändra inte detta annars kommer du inte att kunna använda gratis transform
    // eller ändra det understrykande smarta objektet till vektortypen
    ////resource.PlacedLayerType = PlacedLayerType.Vector;

    // Det bör finnas en giltig PlLdResource med detta unika ID
    ////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;
                }
            }
        }
    }
}

Se även

• class SoLdResource
• class SoLeResource
• class PlacedResource
• interface ISmartObjectLayerResource
• namnutrymme Aspose.PSD.FileFormats.Psd.Layers.LayerResources
• hopsättning Aspose.PSD