I processi di lavoro di Asset compute personalizzati possono produrre dati XMP (XML) che vengono rimandati a AEM e memorizzati come metadati su una risorsa.
I casi d’uso comuni includono:
Questa esercitazione creerà un processo di lavoro per metadati di Asset compute che deriverà i colori più comunemente utilizzati in una risorsa di immagine e riscrive i nomi dei colori nei metadati della risorsa in AEM. Anche se il processo di lavoro è di base, questa esercitazione lo utilizza per esplorare come i processi di lavoro di Asset compute possono essere utilizzati per riscrivere i metadati alle risorse in AEM come Cloud Service.
La chiamata dei processi di lavoro dei metadati di Asset compute è quasi identica a quella di processi di rendering binari che generano processi di lavoro, con la differenza principale che il tipo di ritorno è un rendering XMP (XML) i cui valori sono scritti anche nei metadati della risorsa.
I dipendenti di Asset compute implementano il contratto Asset compute SDK worker API nella funzione renditionCallback(...)
, che è concettualmente:
renditionCallback(...)
del processo di lavoro per metadati di Asset compute personalizzati, derivando un rendering XMP (XML) basato sul rendering binario della risorsa (1a) e su eventuali parametri del profilo di elaborazione (1b).rendition.path
.rendition.path
vengono trasportati tramite l’SDK di Asset compute ad AEM Author Service e li espongono come (4a) una rappresentazione di testo e (4b) persistenti nel nodo di metadati della risorsa.Tutti i lavoratori Asset compute devono essere registrati nel file manifest.yml.
Apri il manifest.yml
del progetto e aggiungi una voce di lavoro che configuri il nuovo processo di lavoro, in questo caso metadata-colors
.
Ricorda .yml
che gli spazi bianchi sono sensibili.
packages:
__APP_PACKAGE__:
license: Apache-2.0
actions:
worker:
function: actions/worker/index.js
web: 'yes'
runtime: 'nodejs:12'
limits:
timeout: 60000 # in ms
memorySize: 512 # in MB
concurrency: 10
annotations:
require-adobe-auth: true
metadata-colors:
function: actions/metadata-colors/index.js
web: 'yes'
runtime: 'nodejs:12'
limits:
memorySize: 512 # in MB
function
fa riferimento all’implementazione del processo di lavoro creata nel passaggio successivo. Denomina i processi di lavoro semanticamente (ad esempio, il actions/worker/index.js
potrebbe essere stato meglio denominato actions/rendition-circle/index.js
), come mostrato nell' URL del processo di lavoro e inoltre determina il nome della cartella di test del processo di lavoro.
Le limits
e require-adobe-auth
sono configurate in modo discreto per lavoratore. In questo processo di lavoro, 512 MB
di memoria viene allocata mentre il codice controlla (potenzialmente) grandi dati di immagine binari. Gli altri limits
vengono rimossi per utilizzare i valori predefiniti.
Crea un nuovo file JavaScript di lavoro metadati nel progetto di Asset compute nel percorso definito manifest.yml per il nuovo processo di lavoro, all'indirizzo /actions/metadata-colors/index.js
Installa i moduli npm aggiuntivi (@adobe/asset-compute-xmp, get-image-color e color-namer) che verranno utilizzati in questo processo di lavoro Asset compute.
$ npm install @adobe/asset-compute-xmp
$ npm install get-image-colors
$ npm install color-namer
Questo processo di lavoro ha un aspetto molto simile al processo di lavoro che genera rendering, la differenza principale consiste nel scrivere i dati XMP (XML) nel rendition.path
per essere salvati di nuovo in AEM.
"use strict";
const { worker, SourceCorruptError } = require("@adobe/asset-compute-sdk");
const fs = require("fs").promises;
// Require the @adobe/asset-compute-xmp module to create XMP
const { serializeXmp } = require("@adobe/asset-compute-xmp");
// Require supporting npm modules to derive image colors from image data
const getColors = require("get-image-colors");
// Require supporting npm modules to convert image colors to color names
const namer = require("color-namer");
exports.main = worker(async (source, rendition, params) => {
// Perform any necessary source (input) checks
const stats = await fs.stat(source.path);
if (stats.size === 0) {
// Throw appropriate errors whenever an erring condition is met
throw new SourceCorruptError("source file is empty");
}
const MAX_COLORS = 10;
const DEFAULT_COLORS_FAMILY = 'basic';
// Read the color family parameter to use to derive the color names
let colorsFamily = rendition.instructions.colorsFamily || DEFAULT_COLORS_FAMILY;
if (['basic', 'hex', 'html', 'ntc', 'pantone', 'roygbiv'].indexOf(colorsFamily) === -1) {
colorsFamily = DEFAULT_COLORS_FAMILY;
}
// Use the `get-image-colors` module to derive the most common colors from the image
let colors = await getColors(source.path, { options: MAX_COLORS });
// Convert the color Chroma objects to their closest names
let colorNames = colors.map((color) => getColorName(colorsFamily, color));
// Serialize the data to XMP metadata
// These properties are written to the [dam:Asset]/jcr:content/metadata resource
// This stores
// - The list of color names is stored in a JCR property named `wknd:colors`
// - The colors family used to derive the color names is stored in a JCR property named `wknd:colorsFamily`
const xmp = serializeXmp({
// Use a Set to de-duplicate color names
"wknd:colors": [...new Set(colorNames)],
"wknd:colorsFamily": colorsFamily
}, {
// Define any property namespaces used in the above property/value definition
// These namespaces will be automatically registered in AEM if they do not yet exist
namespaces: {
wknd: "https://wknd.site/assets/1.0/",
},
}
);
// Save the XMP metadata to be written back to the asset's metadata node
await fs.writeFile(rendition.path, xmp, "utf-8");
});
/**
* Helper function that derives the closest color name for the color, based on the colors family
*
* @param {*} colorsFamily the colors name family to use
* @param {*} color the color to convert to a name
*/
function getColorName(colorsFamily, color) {
if ('hex' === colorsFamily) { return color; }
let names = namer(color.rgb())[colorsFamily];
if (names.length >= 1) { return names[0].name; }
}
Completato il codice del lavoratore, può essere eseguito utilizzando lo strumento di sviluppo Asset compute locale.
Poiché il nostro progetto di Asset compute contiene due processi di lavoro (il precedente rendering dei cerchi e questo processo di lavoro metadata-colors
), la definizione del profilo dello strumento di sviluppo Asset compute elenca i profili di esecuzione per entrambi i processi di lavoro. La seconda definizione del profilo punta al nuovo processo di lavoro metadata-colors
.
Dalla directory principale del progetto Asset compute
Esegui aio app run
per avviare lo strumento di sviluppo di Asset compute
In Seleziona un file…A discesa , scegli un’ immagine di esempio da elaborare
Nella seconda configurazione di definizione del profilo, che punta al processo di lavoro metadata-colors
, aggiorna "name": "rendition.xml"
poiché questo processo di lavoro genera un rendering XMP (XML). Facoltativamente, aggiungi un parametro colorsFamily
(valori supportati basic
, hex
, html
, ntc
, pantone
, roygbiv
).
{
"renditions": [
{
"worker": "...",
"name": "rendition.xml",
"colorsFamily": "pantone"
}
]
}
Tocca Esegui e attendi che il rendering XML venga generato
La sezione Rendering visualizza in anteprima il rendering generato. Toccare il rendition.xml
per scaricarlo e aprirlo nel codice VS (o nell'editor XML/text preferito) per la revisione.
I processi di lavoro dei metadati possono essere testati utilizzando lo stesso framework di test di Asset compute dei rendering binari. L’unica differenza è che il file rendition.xxx
nel caso di test deve essere il rendering previsto XMP (XML).
Crea la seguente struttura nel progetto di Asset compute:
/test/asset-compute/metadata-colors/success-pantone/
file.jpg
params.json
rendition.xml
Utilizza il file di esempio come case di prova file.jpg
.
Aggiungi il seguente JSON al params.json
.
{
"fmt": "xml",
"colorsFamily": "pantone"
}
Tieni presente che per istruire la suite di test è necessario .xml
generare un rendering basato su testo."fmt": "xml"
Immetti il codice XML previsto nel file rendition.xml
. Ciò può essere ottenuto:
<?xml version="1.0" encoding="UTF-8"?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:wknd="https://wknd.site/assets/1.0/"><rdf:Description><wknd:colors><rdf:Seq><rdf:li>Silver</rdf:li><rdf:li>Black</rdf:li><rdf:li>Outer Space</rdf:li></rdf:Seq></wknd:colors><wknd:colorsFamily>pantone</wknd:colorsFamily></rdf:Description></rdf:RDF>
Esegui aio app test
dalla directory principale del progetto Asset compute per eseguire tutte le suite di test.
Per richiamare questo nuovo processo di lavoro metadati da AEM Assets, è necessario distribuirlo in Adobe I/O Runtime utilizzando il comando :
$ aio app deploy
In questo modo verranno distribuiti tutti i processi di lavoro del progetto. Consulta le istruzioni di distribuzione senza limiti per informazioni su come distribuire nelle aree di lavoro di Stage e Produzione.
Richiama il lavoratore da AEM creando un nuovo servizio Profilo di elaborazione personalizzato esistente che richiama il lavoratore distribuito o modificandone uno esistente.
https://...adobeioruntime.net/api/v1/web/wkndAemAssetCompute-0.0.1/metadata-colors
aio app get-url
. Assicurati che l’URL punti nell’area di lavoro corretta in base al AEM come ambiente di Cloud Service.colorFamily
pantone
basic
, hex
, html
, ntc
, pantone
, roygbiv
image/jpeg
, image/png
, image/gif
, image/svg
Leave blank
Per rivedere i metadati dei colori, mappare due nuovi campi dello schema metadati dell'immagine alle nuove proprietà dei dati dei metadati che il processo di lavoro compila.
Colors Family
./jcr:content/metadata/wknd:colorsFamily
Colors
./jcr:content/metadata/wknd:colors
Colors Family
e Colors
campi di metadati per i metadati riscritti dal processo di lavoro per metadati di Asset compute personalizzati.Con i metadati a colori scritti nei metadati della risorsa, sulla risorsa [dam:Asset]/jcr:content/metadata
, questi metadati sono indicizzati e consentono di aumentare la possibilità di scoprire le risorse utilizzando questi termini tramite la ricerca, e possono anche essere riscritti nel file binario della risorsa se su di esso viene richiamato il flusso di lavoro DAM Metadata Writeback .
Anche il file XMP effettivo generato dal processo di lavoro metadati Asset compute viene memorizzato come rendering discreto sulla risorsa. Questo file generalmente non viene utilizzato, ma i valori applicati al nodo di metadati della risorsa vengono utilizzati, ma l'output XML non elaborato del processo di lavoro è disponibile in AEM.
L’ ultima versione metadata-colors/index.js
è disponibile su Github all’indirizzo:
La suite di test finale test/asset-compute/metadata-colors
è disponibile su Github all’indirizzo: