Una prova di cartone Hexachrome, CMYK più arancione e verde in un unico spazio /DeviceN, renderizza la foto del prodotto a strisce diagonali in qualunque decoder che legge quattro componenti per campione. Lo stride giusto è la lunghezza dell'array dei nomi DeviceN — sei componenti qui — e il renderer Delphi di HotPDF lo applica a ogni campione, a ogni coppia Decode, a ogni color key e a ogni vertice della mesh
Quanti colori può portare uno spazio DeviceN?
Tanti quanti ne elenca il suo array dei nomi. Uno spazio DeviceN si scrive come [/DeviceN names alternateSpace tintTransform attributes], e ISO 32000-1 §8.6.6.5 fa di quell'array l'intera definizione del numero di componenti: sei nomi, sei componenti, in quest'ordine. L'Allegato C, Tabella C.1, elenca 32 componenti DeviceN tra i limiti architetturali minimi che i lettori conformi dovrebbero reggere, quindi un file portabile resta a 32 o sotto; ISO 32000-2 mantiene quel numero solo come raccomandazione precedente. I lavori di produzione stanno ben dentro. Hexachrome vuole sei inchiostri, e un lavoro CMYK con tre Pantone spot ne vuole sette. Nemmeno il dizionario opzionale degli attributi cambia il conteggio. Uno spazio NChannel (PDF 1.6) aggiunge le voci /Colorants e /Process che dicono quali nomi sono inchiostri spot e quali sono componenti di processo, eppure ogni campione porta comunque un valore per nome
Il numero di inchiostri fissa anche il numero di ingressi del tint transform, la funzione che mappa n tint verso lo spazio alternativo per la visualizzazione. La nota sulle funzioni di Type 4 in §7.10.5 usa Hexachrome come esempio personale: una trasformazione a sei ingressi e quattro uscite campionata a m punti per ingresso vuole 4 × m6 valori, quindi a m = 16 la tabella conterebbe oltre 67 milioni di numeri. Ecco perché la maggior parte dei produttori scrive un tint transform a sei inchiostri come un breve programma calcolatore PostScript. Ciò che lo spazio alternativo mostra, e quando un dispositivo stampa l'inchiostro vero, è il terreno di rendering di Separation e DeviceN spot color. Tutto ciò che segue qui sotto succede prima. Il renderer sta ancora tirando fuori numeri grezzi dal file
Quali strutture dati sono dimensionate da n?
Ogni struttura che contiene un valore per componente, e la specifica dichiara la dimensione ogni volta. Un renderer con un buffer fisso da quattro slot decodifica il primo pixel giusto per caso e tutti i successivi sbagliati, perché la posizione di lettura deraglia di due componenti per campione:
| Struttura | Dimensione per n colori | Regola |
|---|---|---|
| Campione immagine | n componenti di BitsPerComponent bit ciascuna | §8.9.2 |
Array /Decode | 2n numeri, una coppia min/max per componente | §8.9.5.2 |
Color key /Mask | 2n interi, confrontati prima della decodifica | §8.9.6.4 |
| Tabella di lookup indexed sopra DeviceN | n × (hival + 1) byte | §8.6.6.3 |
| Tiling pattern non colorato | n tint davanti al nome del pattern in scn | §8.7.3.3 |
| Colore shading (Type 1–7) | n valori, o le uscite di /Function | §8.7.4.5 |
| Vertice mesh (Type 4–7) | n valori colore, o un singolo parametro t quando lo shading ha un /Function | §8.7.4.5.5 in poi |
Uno shading può rompersi nella sua funzione o nella sua mesh. Uno shading axiale o radiale prende il colore da /Function, che può essere una funzione con n uscite o un array di n funzioni a una sola uscita, una per inchiostro; un renderer che ne valuta quattro lascia arancione e verde a zero, e il gradiente sul coperchio degenera verso CMYK puro. Anche la voce /Background è di n valori. Il caso mesh è il peggiore. Una free-form triangle mesh impacchetta flag, coordinate e colore in un unico bit stream per vertice, così un decoder che consuma quattro valori colore per uno spazio a sei inchiostri ne lascia due non letti, e quelli diventano il flag e la coordinata x del vertice successivo. I triangoli volano fuori pagina o collassano in fettine. L'output mostra triangoli fuori posto, non colori sbagliati, il che manda la gente a cercare un bug di geometria
Le immagini indexed su una base a sei inchiostri sono più docili ma altrettanto visibili. La voce di palette per l'indice i parte dal byte 6i, non 4i, così ogni voce dopo l'indice 0 raccoglie un mix degli inchiostri della vicina. Una palette completa da 256 voci su quella base fa 1.536 byte. Scritta come hex string vuole 3.072 cifre esadecimali, e §7.3.4.3 lascia spazio bianco in mezzo e tratta una cifra finale dispari come se uno 0 la seguisse. HotPDF legge le palette binarie ed esadecimali alla larghezza reale della base e limita un indice immagine sopra hival a hival, così un campione fuori range sparso dipinge l'ultima voce della palette. Le regole per gli altri spazi di base, e per le palette la cui base rimanda a se stessa, stanno in Palette indexed e i loro spazi colore di base
Campioni sub-byte e a 16 bit, Decode e color key
Qualunque profondità di bit legale può comparire. I file di packaging portano lastre di vernice o inchiostro bianco a 1 bit e livelli spot a 4 bit, e il dizionario immagine ammette 16 bit per componente da PDF 1.5 in poi. La mappatura in §8.9.5.2 è lineare su 0 a 2bpc − 1, quindi un campione a 4 bit di 15 è a piena forza; il codice che divide ogni campione per 255 stampa quella lastra al sei per cento circa. A 16 bit ogni campione è due byte, byte alto prima, mappato da 0..65535 sul range Decode. HotPDF decodifica le immagini Separation e DeviceN a 1, 2, 4, 8 e 16 bit per componente con quella formula
Il color key masking aggiunge una regola di tempismo. L'array /Mask contiene 2n interi, §8.9.6.4 li confronta con i campioni grezzi prima che il Decode venga applicato, e un pixel le cui componenti cadono tutte dentro il proprio range non viene dipinto. Per un'immagine a sei inchiostri a 8 bit, [0 0 0 0 0 0 0 0 0 0 0 255] maschera via ogni pixel senza inchiostro nei primi cinque colori, qualunque sia il sesto, e a 16 bit i range arrivano a 65535. Gli helper qui sotto seguono quell'ordine di lettura; ogni riga immagine parte su un confine di byte:
const
MaxColorants = 32; // ISO 32000-1 Annex C, Table C.1
type
TColorantTints = array[0..MaxColorants - 1] of Double;
// Valore grezzo del componente C del pixel X in una riga impacchettata a Bpc (1, 2, 4, 8, 16)
function RawComponent(const Row: TBytes; X, C, N, Bpc: Integer): Cardinal;
var
BitPos, ByteIdx: Integer;
begin
if Bpc = 16 then
begin
ByteIdx := (X * N + C) * 2; // big-endian: prima il byte alto
Result := (Cardinal(Row[ByteIdx]) shl 8) or Row[ByteIdx + 1];
Exit;
end;
BitPos := (X * N + C) * Bpc;
Result := (Row[BitPos div 8] shr (8 - Bpc - BitPos mod 8)) and ((1 shl Bpc) - 1);
end;
// Test del color key sui campioni grezzi: Mask contiene 2n interi
function IsKeyedOut(const Row: TBytes; X, N, Bpc: Integer;
const Mask: array of Integer): Boolean;
var
C: Integer;
V: Integer;
begin
for C := 0 to N - 1 do
begin
V := Integer(RawComponent(Row, X, C, N, Bpc));
if (V < Mask[2 * C]) or (V > Mask[2 * C + 1]) then
Exit(False);
end;
Result := True;
end;
// Mappatura Decode lineare su 0..2^bpc - 1, una coppia Decode per colore
procedure DecodePixel(const Row: TBytes; X, N, Bpc: Integer;
const Decode: array of Double; var Tints: TColorantTints);
var
C: Integer;
MaxRaw: Double;
begin
MaxRaw := (1 shl Bpc) - 1; // 65535 a 16 bpc
for C := 0 to N - 1 do
Tints[C] := Decode[2 * C] + RawComponent(Row, X, C, N, Bpc) *
(Decode[2 * C + 1] - Decode[2 * C]) / MaxRaw;
end;
Con un'immagine a sei inchiostri a 4 bit e il Decode predefinito [0 1 0 1 0 1 0 1 0 1 0 1], un 15 grezzo nel canale arancione dovrebbe uscire da DecodePixel come tint 1.0. Un lettore a quattro componenti mette lo stesso nibble su un canale completamente diverso. Il pixel 1 parte al bit 24, non al bit 16. Il ramo a 16 bit legge due byte per componente, così lo stesso pixel di un'immagine a 16 bit parte al byte 12, e IsKeyedOut confronta il valore completo a 16 bit con la chiave
Cosa controlla HotPDF prima di decodificare un'immagine a sei inchiostri?
Se l'immagine e il suo spazio colore concordano su n. GetLoadedImageInfo riporta la famiglia dello spazio colore, il numero di componenti preso dall'array dei nomi, la profondità di bit e un flag Decodable, così un'immagine a sei inchiostri si annuncia prima che un pixel venga letto. Un'immagine il cui numero di componenti dichiarato discorda dal suo spazio colore non viene decodificata affatto, e ExtractLoadedImage ritorna nil per lei; uno stride indovinato non farebbe che riprodurre le strisce della prova di cartone. Un'immagine inline (BI … ID … EI) può nominare uno spazio DeviceN dalle risorse /ColorSpace della pagina ai sensi di §8.9.7, e HotPDF risolve quel nome e legge i campioni inline allo stesso n. I tint transform portano un compromesso. Una funzione campionata cubica legge quattro punti di reticolo per ingresso, 4n in tutto, quindi sopra i quattro ingressi HotPDF interpola la tabella dei campioni multilinearmemente, che legge 2n punti e tiene il costo di lookup limitato. Per una trasformazione a sei ingressi sono 64 letture per valore in uscita contro 4.096. Il risparmio cresce in fretta
var
Pdf: THotPDF;
Info: THPDFLoadedImageInfo;
Inks: THPDFAnsiStringArray;
Proof, Plate: TBitmap;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
Pdf.LoadFromFile('carton-hexachrome.pdf');
// Quali immagini usano uno spazio a molti colori, e si possono decodificare?
for I := 0 to Pdf.GetLoadedImageCount - 1 do
if Pdf.GetLoadedImageInfo(I, Info) then
Writeln(Format('image %d: %s, %d components, %d bpc, decodable=%s',
[I, string(Info.ColorSpace), Info.ColorComponents,
Info.BitsPerComponent, BoolToStr(Info.Decodable, True)]));
// Nomi dei colori da ogni spazio Separation / DeviceN della pagina 1
Inks := Pdf.GetLoadedPageSpotColorants(0);
for I := 0 to High(Inks) do
Writeln('colorant on page 1: ', string(Inks[I]));
// Prova composita con simulazione overprint, poi una lastra da sola
Pdf.RenderOverprintPreview := True;
Proof := Pdf.RenderLoadedPageToBitmap(0, 150);
try
Proof.SaveToFile('carton-proof.bmp');
finally
Proof.Free;
end;
Plate := Pdf.RenderLoadedPageSeparationPlate(0, 150, 'Orange');
try
Plate.SaveToFile('carton-orange-plate.bmp');
finally
Plate.Free;
end;
finally
Pdf.Free;
end;
end;
Lastre Separation e nomi di processo NChannel
Le lastre chiudono le discussioni. Quando il file di un fornitore si renderizza in un modo nel loro strumento e nell'altro nel vostro, una singola lastra persuade più di una composita: una lastra Orange decodificata correttamente mostra l'opera in arancione e nient'altro, mentre un errore di stride la sbava sulle lastre vicine. GetLoadedPageSpotColorants riporta i nomi dei colori così come li scrive ogni array dei nomi Separation o DeviceN, seguendo XObject, pattern, shading e soft mask, così uno spazio Hexachrome contribuisce tutti e sei i nomi, da Cyan a Green. Una lista di lastre che deve distinguere gli inchiostri di processo dagli spot può leggere gli attributi NChannel: il dizionario /Process nomina i componenti di processo nel suo array /Components, e ogni nome spot prende il suo spazio Separation sotto /Colorants (§8.6.6.5). Preferite questa strada al tirare a indovinare dai nomi tipo Cyan, perché la specifica lascia che un componente di processo non CMYK porti qualunque nome. Per la composita, RenderOverprintPreview simula gli inchiostri che si stampano l'uno sopra l'altro, e le impostazioni dei dispositivi in CMYK overprint proofing e dispositivi di render decidono quanto arriva quella simulazione
Partite dall'immagine che va a strisce. Se GetLoadedImageInfo dice sei componenti e il vostro decoder avanza di quattro, la colpa è dello stride, e una lastra Orange renderizzata con il componente PDF HotPDF per Delphi mostra al fornitore quali pixel appartengono a quell'inchiostro