Class PlacedResource

PlacedResource class

Definisce la classe PlacedResource che contiene informazioni comuni su un livello posizionato o un livello oggetto avanzato nel file PSD. Viene utilizzato per supportare i livelli oggetto avanzato nelle immagini di Adobe® Photoshop®.

public abstract class PlacedResource : LayerResource, IPlacedLayerResource

Proprietà

Nome	Descrizione
virtual AntiAliasPolicy { get; set; }	Ottiene o imposta la politica anti alias del livello inserito nell’immagine PSD.
Bottom { get; set; }	Ottiene o imposta la posizione inferiore del livello posizionato nell’immagine PSD.
Bounds { get; set; }	Ottiene o imposta i limiti del livello posizionato nel file PSD.
HorizontalMeshPoints { get; set; }	Ottiene o imposta i punti di mesh orizzontale del livello posizionato nel file PSD.
HorizontalMeshPointUnit { get; set; }	Ottiene o imposta l’unità di misura dei punti della maglia orizzontale.
IsCustom { get; set; }	Ottiene o imposta un valore che indica se lo stile warp di questa istanza è personalizzato. Se vero contiene punti mesh. Se impostato su false cancella i punti mesh.
virtual Items { get; set; }	Ottiene o imposta gli elementi di curvatura.
abstract Key { get; }	Ottiene la chiave della risorsa del livello.
Left { get; set; }	Ottiene o imposta la posizione a sinistra del livello inserito nel file PSD.
abstract Length { get; }	Ottiene la lunghezza della risorsa del livello in byte.
virtual PageNumber { get; set; }	Ottiene o imposta il numero di pagina del livello inserito nel file PSD.
Perspective { get; set; }	Ottiene o imposta il valore prospettico del livello inserito nel file PSD.
PerspectiveOther { get; set; }	Ottiene o imposta l’altro valore della prospettiva del livello inserito nel file PSD.
virtual PlacedLayerType { get; set; }	Ottiene o imposta il tipo di layer posizionato nel file PSD.
abstract PsdVersion { get; }	Ottiene la versione PSD minima richiesta per la risorsa del livello. 0 indica nessuna restrizione.
Right { get; set; }	Ottiene o imposta la posizione corretta del livello inserito nel file PSD.
override Signature { get; }	Ottiene la firma della risorsa inserita.
Top { get; set; }	Ottiene o imposta la posizione superiore del livello inserito nell’immagine PSD.
virtual TotalPages { get; set; }	Ottiene o imposta le pagine totali del livello posizionato nel file PSD.
virtual TransformMatrix { get; set; }	Ottiene o imposta la matrice di trasformazione del livello posizionato nel file PSD.
virtual UniqueId { get; set; }	Ottiene o imposta l’identificatore univoco globale del livello posizionato nell’immagine PSD.
UOrder { get; set; }	Ottiene o imposta il valore dell’ordine U del livello inserito nel file PSD.
Value { get; set; }	Ottiene o imposta il valore di distorsione del livello posizionato nell’immagine PSD.
Version { get; }	Ottiene la versione del livello posizionato nel file PSD, in genere 3.
VerticalMeshPoints { get; set; }	Ottiene o imposta i punti di mesh orizzontale del livello posizionato nel file PSD.
VerticalMeshPointUnit { get; set; }	Ottiene o imposta l’unità di misura dei punti della maglia verticale.
VOrder { get; set; }	Ottiene o imposta il valore dell’ordine V del livello posizionato nel file PSD.

Metodi

Nome	Descrizione
abstract Save(StreamContainer, int)	Salva la risorsa nel contenitore del flusso specificato.
override ToString()	Restituisce aString che rappresenta questa istanza.

Esempi

Il codice seguente dimostra il supporto delle risorse SoLEResource, SmartObjectResource e 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)
{
    // Questi valori non vengono modificati nella risorsa
    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;

    // Questi valori devono essere modificati anche in PlLdResource (con l'UniqueId specificato).
    // e alcuni di essi devono essere in accordo con l'oggetto intelligente sottolineato nel 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];

    // Questo ID univoco deve essere modificato nei riferimenti, se presenti
    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];
    }

    // Fai attenzione ad alcuni parametri: l'immagine salvata potrebbe diventare illeggibile da Adobe® Photoshop®
    ////risorsa.UOrdine = 6;
    ////risorsa.VOrder = 9;

    // Non cambiarlo altrimenti non sarai in grado di usare la trasformazione libera
    // o cambia l'oggetto intelligente sottolineato nel tipo vettoriale
    ////resource.PlacedLayerType = PlacedLayerType.Vector;

    // Dovrebbe esserci PlLdResource valido con questo ID univoco
    ////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;
                }
            }
        }
    }
}

Guarda anche

• class LayerResource
• interface IPlacedLayerResource
• spazio dei nomi Aspose.PSD.FileFormats.Psd.Layers.LayerResources
• assemblea Aspose.PSD