Class SoLdResource

SoLdResource class

Definisce la classe SoLdResource che contiene informazioni su un livello oggetto avanzato in un file PSD. Viene utilizzato per supportare i livelli oggetto avanzato nelle immagini di Adobe® Photoshop®.

public class SoLdResource : SmartObjectResource

Costruttori

NomeDescrizione
SoLdResource()Inizializza una nuova istanza diSoLdResource class. Questo costruttore predefinito è progettato per essere utilizzato daSoLdResourceLoader . UsaSmartResourceCreator per la creazione di classi SoLdResource.
SoLdResource(Guid, bool, bool)Inizializza una nuova istanza diSoLdResource class. È necessario impostare la proprietà Items o chiamare InitializeItems() per ottenere un’istanza pronta. Questo costruttore è progettato per essere utilizzato daSmartResourceCreator e nei test unitari. UsaSmartResourceCreator per la creazione di classi SoLdResource.

Proprietà

NomeDescrizione
override AntiAliasPolicy { get; set; }Ottiene o imposta la politica anti alias dei dati del livello degli oggetti avanzati 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.
Comp { get; set; }Ottiene o imposta il valore comp dei dati del livello oggetto avanzato nel file PSD. Composizioni di livelli in Oggetti avanzati
CompId { get; set; }Ottiene o imposta l’ID della composizione attualmente selezionata per il documento figlio, che sarà -1 se non ne viene selezionato nessuno. Le composizioni sono composizioni di un layout di pagina che i designer possono creare. Utilizzando le composizioni di livelli, puoi creare, gestire e visualizzare più versioni di un layout in un unico file Adobe® Photoshop®. Una composizione di livelli è un’istantanea di uno stato del pannello Livelli. Le composizioni di livelli salvano tre tipi di opzioni di livello ma questa proprietà ottiene l’identificatore di selezione della composizione di livelli per il livello oggetto avanzato nel file PSD. Composizioni di livelli in Oggetti avanzati
Crop { get; set; }Ottiene o imposta il ritaglio dei dati del livello oggetto intelligente nell’immagine PSD.
DurationDenominator { get; set; }Ottiene o imposta il denominatore della durata.
DurationNumerator { get; set; }Ottiene o imposta il numeratore della durata.
FrameCount { get; set; }Ottiene o imposta il numero di fotogrammi dei dati del livello degli oggetti avanzati nel file PSD.
FrameStepDenominator { get; set; }Ottiene o imposta il denominatore del passo del fotogramma.
FrameStepNumerator { get; set; }Ottiene o imposta il numeratore del passo del fotogramma.
Height { get; set; }Ottiene o imposta l’altezza.
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.
override Items { get; set; }Ottiene o imposta gli elementi descrittori dei dati del livello degli oggetti intelligenti nel file PSD.
override Key { get; }Ottiene la chiave della risorsa SoLd Smart Object Layer.
Left { get; set; }Ottiene o imposta la posizione a sinistra del livello inserito nel file PSD.
override Length { get; }Ottiene la lunghezza della risorsa oggetto intelligente in byte.
NonAffineTransformMatrix { get; set; }Ottiene o imposta la matrice di trasformazione non affine dei dati del livello degli oggetti avanzati nel file PSD.
OriginalCompId { get; }Ottiene l’ID originale del Comp attualmente selezionato per il documento secondario, che sarà -1 se non ne viene selezionato nessuno. Questa proprietà ottiene l’identificatore di selezione Comp del livello originale per il livello oggetto avanzato nel file PSD. Composizioni di livelli in Oggetti avanzati
override PageNumber { get; set; }Ottiene o imposta il numero di pagina dei dati del livello oggetto avanzato 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.
PlacedId { get; set; }Ottiene o imposta l’identificatore univoco di questi dati del livello oggetto avanzato nell’immagine PSD.
override PlacedLayerType { get; set; }Ottiene o imposta il tipo di dati del livello oggetto avanzato nel file PSD.
override PsdVersion { get; }Ottiene la versione PSD minima richiesta per la risorsa oggetto avanzato. 0 indica nessuna restrizione.
Resolution { get; set; }Ottiene o imposta la risoluzione dei dati del livello degli oggetti intelligenti nel file PSD.
ResolutionUnit { get; set; }Ottiene o imposta l’unità di misura della risoluzione dei dati del livello degli oggetti avanzati nel file PSD.
Right { get; set; }Ottiene o imposta la posizione corretta del livello inserito nel file PSD.
override Signature { get; }Ottiene la firma della risorsa oggetto intelligente.
Top { get; set; }Ottiene o imposta la posizione superiore del livello inserito nell’immagine PSD.
override TotalPages { get; set; }Ottiene o imposta il numero totale di pagine dei dati del livello oggetto avanzato nel file PSD.
override TransformMatrix { get; set; }Ottiene o imposta la matrice di trasformazione dei dati del livello degli oggetti intelligenti nel file PSD.
override UniqueId { get; set; }Ottiene o imposta l’identificatore univoco globale dei dati del livello degli oggetti avanzatiSmartObjectResource 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.
Width { get; set; }Ottiene o imposta la larghezza.

Metodi

NomeDescrizione
override Save(StreamContainer, int)Salva la risorsa oggetto avanzato nel contenitore di flusso specificato.
override ToString()Restituisce aString che rappresenta questa istanza.

Campi

NomeDescrizione
const TypeToolKeyLa chiave informativa dello strumento di digitazione: ‘SoLd’.

Esempi

Il codice seguente illustra il supporto della risorsa SoLdResource.

[C#]

// Questo esempio mostra come ottenere o impostare le proprietà dei dati del livello oggetto avanzato del file PSD.

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
        },
        0.0,
        0.0,
        0.0,
        0d,
        0d,
        149d,
        310d,
        4,
        4,
        1,
        0,
        600,
        0,
        600,
        1,
        310d,
        149d,
        72d,
        UnitTypes.Density,
        -1,
        -1,
        -1,
        "d3388655-19e4-9742-82f2-f553bb01046a",
        new double[8]
        {
            29.937922786050663,
            95.419959734187131,
            126.85445817782261,
            1.0540625423957124,
            172.20861031651307,
            47.634102808208553,
            75.292074924741144,
            142
        },
        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,
        },
        0.0,
        0.0,
        0.0,
        0d,
        0d,
        721d,
        1280d,
        4,
        4,
        1,
        0,
        600,
        0,
        600,
        1,
        1280d,
        721d,
        72d,
        UnitTypes.Density,
        -1,
        -1,
        -1,
        "625cc4b9-2c5f-344f-8636-03caf2bd3489",
        new double[8]
        {
            37.900314592235681,
            -0.32118219433001371,
            185.94210608826535,
            57.7076819802063,
            153.32047433609358,
            140.9311755779743,
            5.2786828400639294,
            82.902311403437977,
        },
        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))
{
    SoLdResource resource = null;
    int index = 0;
    foreach (Layer imageLayer in image.Layers)
    {
        foreach (var imageResource in imageLayer.Resources)
        {
            resource = imageResource as SoLdResource;
            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);

                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((IEnumerable)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);
                    var temp = resource.VerticalMeshPoints;
                    resource.VerticalMeshPoints = resource.HorizontalMeshPoints;
                    resource.HorizontalMeshPoints = temp;
                }

                // 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 = 2;
                resource.TotalPages = 3;
                resource.AntiAliasPolicy = 0;
                resource.Value = 1.23456789;
                resource.Perspective = 0.123456789;
                resource.PerspectiveOther = 0.987654321;
                resource.Top = -126;
                resource.Left = -215;
                resource.Bottom = 248;
                resource.Right = 145;
                resource.Crop = 4;
                resource.FrameStepNumerator = 1;
                resource.FrameStepDenominator = 601;
                resource.DurationNumerator = 2;
                resource.DurationDenominator = 602;
                resource.FrameCount = 11;
                resource.Width = 541;
                resource.Height = 249;
                resource.Resolution = 144;
                resource.Comp = 21;
                resource.CompId = 22;
                resource.TransformMatrix = new double[8]
                {
                    12.937922786050663,
                    19.419959734187131,
                    2.85445817782261,
                    1.0540625423957124,
                    7.20861031651307,
                    14.634102808208553,
                    17.292074924741144,
                    4
                };
                resource.NonAffineTransformMatrix = new double[8]
                {
                    129.937922786050663,
                    195.419959734187131,
                    26.85445817782261,
                    12.0540625423957124,
                    72.20861031651307,
                    147.634102808208553,
                    175.292074924741144,
                    42
                };

                // Questo ID univoco deve essere modificato nei riferimenti, se presenti
                resource.PlacedId = new Guid("12345678-9abc-def0-9876-54321fecba98");

                // Fai attenzione ad alcuni parametri: l'immagine 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");

                break;
            }
        }
    }

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

Guarda anche

Class SoCoResource Class SoLeResource