Class SoLeResource

SoLeResource class

Define la clase SoLeResource que contiene información sobre una capa de objetos inteligentes en un archivo PSD. Se utiliza para admitir capas de objetos inteligentes con enlaces de archivos externos en las imágenes de Adobe® Photoshop®.

public class SoLeResource : SmartObjectResource

Constructores

Nombre	Descripción
SoLeResource()	Inicializa una nueva instancia del`SoLeResource` clase.
SoLeResource(Guid, bool, bool)	Inicializa una nueva instancia del`SoLeResource` clase.

Propiedades

Nombre	Descripción
override AntiAliasPolicy { get; set; }	Obtiene o establece la política antialiasing de los datos de la capa de objetos inteligentes en la imagen PSD.
Bottom { get; set; }	Obtiene o establece la ubicación inferior de la capa colocada en la imagen PSD.
Bounds { get; set; }	Obtiene o establece los límites de la capa colocada en el archivo PSD.
Comp { get; set; }	Obtiene o establece el valor de compensación de los datos de la capa del objeto inteligente en el archivo PSD. Composiciones de capas en objetos inteligentes
CompId { get; set; }	Obtiene o establece el ID de la composición actualmente seleccionada para el documento secundario, que será -1 si no se selecciona ninguna. Las composiciones son composiciones de un diseño de página que los diseñadores pueden crear. Con las composiciones de capas, puede crear, administrar y ver varias versiones de un diseño en un solo archivo de Adobe® Photoshop®. Una composición de capa es una instantánea de un estado del panel Capas. Las composiciones de capa guardan tres tipos de opciones de capa pero esta propiedad obtiene el identificador de selección de composición de capa para la capa de objeto inteligente en el archivo PSD. Composiciones de capas en objetos inteligentes
Crop { get; set; }	Obtiene o establece el recorte de los datos de la capa del objeto inteligente en la imagen PSD.
DurationDenominator { get; set; }	Obtiene o establece el denominador de duración.
DurationNumerator { get; set; }	Obtiene o establece el numerador de duración.
FrameCount { get; set; }	Obtiene o establece el número de fotogramas de los datos de la capa del objeto inteligente en el archivo PSD.
FrameStepDenominator { get; set; }	Obtiene o establece el denominador de paso de cuadro.
FrameStepNumerator { get; set; }	Obtiene o establece el numerador de pasos de cuadro.
Height { get; set; }	Obtiene o establece la altura.
HorizontalMeshPoints { get; set; }	Obtiene o establece los puntos de malla horizontal de la capa colocada en el archivo PSD.
HorizontalMeshPointUnit { get; set; }	Obtiene o establece la unidad de medida de los puntos de la malla horizontal.
IsCustom { get; set; }	Obtiene o establece un valor que indica si el estilo de deformación de esta instancia es personalizado. Si es verdadero, contiene puntos de malla. Si se establece en falso, borra los puntos de malla.
override Items { get; set; }	Obtiene o establece los elementos descriptores de los datos de la capa de objeto inteligente en el archivo PSD.
override Key { get; }	Obtiene la clave de recurso de la capa de objeto inteligente único.
Left { get; set; }	Obtiene o establece la ubicación izquierda de la capa colocada en el archivo PSD.
override Length { get; }	Obtiene la longitud del recurso del objeto inteligente en bytes.
NonAffineTransformMatrix { get; set; }	Obtiene o establece la matriz de transformación no afín de los datos de la capa de objeto inteligente en el archivo PSD.
OriginalCompId { get; }	Obtiene el ID original del Comp seleccionado actualmente para el documento secundario, que será -1 si no se selecciona ninguno. Esta propiedad obtiene el identificador de selección de Comp de capa original para la capa de objeto inteligente en el archivo PSD. Composiciones de capas en objetos inteligentes
override PageNumber { get; set; }	Obtiene o establece el número de página de los datos de la capa del objeto inteligente en el archivo PSD.
Perspective { get; set; }	Obtiene o establece el valor de perspectiva de la capa colocada en el archivo PSD.
PerspectiveOther { get; set; }	Obtiene o establece el otro valor de perspectiva de la capa colocada en el archivo PSD.
PlacedId { get; set; }	Obtiene o establece el identificador único de los datos de esta capa de objeto inteligente en la imagen PSD.
override PlacedLayerType { get; set; }	Obtiene o establece el tipo de datos de la capa de objeto inteligente en el archivo PSD.
override PsdVersion { get; }	Obtiene la versión psd mínima necesaria para el recurso de objeto inteligente. 0 indica que no hay restricciones.
Resolution { get; set; }	Obtiene o establece la resolución de los datos de la capa del objeto inteligente en el archivo PSD.
ResolutionUnit { get; set; }	Obtiene o establece la unidad de medida de resolución de los datos de la capa de objeto inteligente en el archivo PSD.
Right { get; set; }	Obtiene o establece la ubicación correcta de la capa colocada en el archivo PSD.
override Signature { get; }	Obtiene la firma del recurso del objeto inteligente.
Top { get; set; }	Obtiene o establece la ubicación superior de la capa colocada en la imagen PSD.
override TotalPages { get; set; }	Obtiene o establece el número total de páginas de los datos de la capa de objeto inteligente en el archivo PSD.
override TransformMatrix { get; set; }	Obtiene o establece la matriz de transformación de los datos de la capa de objeto inteligente en el archivo PSD.
override UniqueId { get; set; }	Obtiene o establece el identificador único global de los datos de la capa de objeto inteligente`SmartObjectResource` en la imagen PSD.
UOrder { get; set; }	Obtiene o establece el valor de orden U de la capa colocada en el archivo PSD.
Value { get; set; }	Obtiene o establece el valor de deformación de la capa colocada en la imagen PSD.
Version { get; }	Obtiene la versión de la capa colocada en el archivo PSD, generalmente 3.
VerticalMeshPoints { get; set; }	Obtiene o establece los puntos de malla horizontal de la capa colocada en el archivo PSD.
VerticalMeshPointUnit { get; set; }	Obtiene o establece la unidad de medida de los puntos de malla vertical.
VOrder { get; set; }	Obtiene o establece el valor de orden V de la capa colocada en el archivo PSD.
Width { get; set; }	Obtiene o establece el ancho.

Métodos

Nombre	Descripción
override Save(StreamContainer, int)	Guarda el recurso de objeto inteligente en el contenedor de flujo especificado.
override ToString()	Devuelve unString que representa esta instancia.

Campos

Nombre	Descripción
const TypeToolKey	La clave de información de la herramienta tipo: ‘SoLE’.

Ejemplos

El siguiente código demuestra la compatibilidad con los recursos SoLEResource, SmartObjectResource y 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)
{
    // Estos valores no los cambiamos en el recurso
    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;

    // Estos valores también deben cambiarse en PlLdResource (con el UniqueId especificado)
    // y algunos de ellos deben estar de acuerdo con el objeto inteligente subrayado en 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];

    // Esta identificación única debe cambiarse en las referencias, si las hay
    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];
    }

    // Tenga cuidado con algunos parámetros: la imagen guardada puede volverse ilegible para Adobe® Photoshop®
    ////recurso.UOrder = 6;
    ////recurso.VOrden = 9;

    // No cambie esto, de lo contrario no podrá usar la transformación libre
    // o cambie el objeto inteligente subrayado al tipo de vector
    ////recurso.PlacedLayerType = PlacedLayerType.Vector;

    // Debería haber un PlLdResource válido con este ID único
    ////recurso.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;
                }
            }
        }
    }
}

Ver también

class SmartObjectResource
espacio de nombres Aspose.PSD.FileFormats.Psd.Layers.LayerResources
asamblea Aspose.PSD

Class SoLdResource Class Txt2Resource