Een Hexachrome-proefdoos, CMYK plus oranje en groen in één /DeviceN-ruimte, rendert zijn productfoto als diagonale strepen in elke decoder die vier componenten per sample leest. De juiste stride is de lengte van de DeviceN-names-array — hier zes componenten — en de Delphi-renderer van HotPDF past die toe op elke sample, elk Decode-paar, elke color key en elke mesh-vertex
Hoeveel kleurcomponenten kan één DeviceN-ruimte bevatten?
Zoveel als de names-array opsomt. Een DeviceN-ruimte wordt geschreven als [/DeviceN names alternateSpace tintTransform attributes], en ISO 32000-1 §8.6.6.5 maakt die array tot de volledige definitie van het componentaantal: zes namen, zes componenten, in die volgorde. Bijlage C, tabel C.1, noemt 32 DeviceN-componenten bij de minimale architectuurlimieten die conforme lezers aan moeten kunnen, dus een draagbaar bestand blijft op of onder de 32; ISO 32000-2 houdt dat getal slechts aan als die eerdere aanbeveling. Productieklussen zitten ruim daaronder. Hexachrome heeft zes inkten nodig, en een CMYK-klus met drie Pantone-spotkleuren heeft er zeven nodig. Het optionele attributes-woordenboek verandert het aantal ook niet. Een NChannel-ruimte (PDF 1.6) voegt /Colorants- en /Process-entries toe die zeggen welke namen spotinkten zijn en welke procescomponenten, maar elke sample draagt nog steeds één waarde per naam
Het inktantal bepaalt ook het aantal ingangen van de tinttransformatie, de functie die n tints aan de alternate space toewijst voor weergave. De noot bij Type 4-functies in §7.10.5 gebruikt Hexachrome als eigen voorbeeld: een transform van zes in en vier uit, bemonsterd op m punten per ingang, heeft 4 × m6 waarden nodig, dus bij m = 16 zou de tabel meer dan 67 miljoen getallen bevatten. Daarom schrijven de meeste producenten een tinttransformatie voor zes inkten als een kort PostScript-calculatorprogramma. Wat de alternate space toont, en wanneer een apparaat de echte inkt op het papier zet, is waar het renderen van Separation- en DeviceN-spotkleuren begint. Alles hieronder gebeurt daarvoor. De renderer is nog bezig rauwe getallen uit het bestand te trekken
Welke datastructuren worden geschaald op n?
Elke structuur die één waarde per component bewaart, en de specificatie vermeldt de grootte telkens expliciet. Een renderer met een vaste buffer van vier plekken decodeert de eerste pixel per toeval correct en elke latere pixel verkeerd, omdat de leespositie per sample twee componenten opschuift:
| Structuur | Grootte bij n kleurcomponenten | Regel |
|---|---|---|
| Image sample | n componenten van elk BitsPerComponent bits | §8.9.2 |
/Decode-array | 2n getallen, één min/max-paar per component | §8.9.5.2 |
Color key /Mask | 2n integers, vergeleken vóór het decoderen | §8.9.6.4 |
| Indexed-opzoektabel op een DeviceN-basis | n × (hival + 1) bytes | §8.6.6.3 |
| Ongekleurd tiling-patroon | n tints vóór de pattern-naam in scn | §8.7.3.3 |
| Shadingkleur (Types 1–7) | n waarden, of de uitgangen van /Function | §8.7.4.5 |
| Mesh-vertex (Types 4–7) | n kleurwaarden, of één enkele parameter t als de shading een /Function heeft | §8.7.4.5.5 en verder |
Een shading kan kapot in zijn functie of in zijn mesh. Een axiale of radiale shading haalt zijn kleur uit /Function, die één functie met n uitgangen kan zijn of een array van n functies met elk één uitgang, één per inkt; evalueert een renderer er vier, dan blijven oranje en groen op nul staan en schuift het verloop over het deksel richting pure CMYK. De /Background-entry is ook n waarden. Het mesh-geval is het smerigst. Een free-form triangle mesh pakt flag, coördinaten en kleur in één bitstroom per vertex, dus een decoder die vier kleurwaarden verbruikt voor een ruimte met zes inkten laat er twee ongelezen liggen, en die worden de flag en x-coördinaat van de volgende vertex. Triangles schieten van de pagina af of versmallen tot splinters. De uitvoer toont verplaatste triangles, niet verkeerde kleuren, wat mensen op jacht stuurt naar een geometriefout
Indexed-afbeeldingen boven een basis met zes inkten zijn milder maar net zo zichtbaar. De palette-entry voor index i begint op byte 6i, niet 4i, dus elke entry na index 0 pakt een mix van de inkten van zijn buurman. Een volledige palette met 256 entries boven die basis is 1.536 bytes. Als hex-string geschreven heeft die 3.072 hexadecimale cijfers nodig, en §7.3.4.3 staat witruimte ertussen toe en behandelt een oneven laatste cijfer alsof er een 0 achter staat. HotPDF leest binaire en hex-palettes op de echte breedte van de basis en klemt een afbeeldingsindex boven hival af op hival, dus een losse sample buiten bereik verft de laatste palette-entry. De regels voor de andere basisruimtes, en voor palettes waarvan de basis naar zichzelf verwijst, staan in Indexed-palettes en hun basis-kleurruimtes
Sub-byte- en 16-bit-samples, Decode en de color key
Elke legale bitdiepte kan voorkomen. Verpakkingsbestanden bevatten 1-bit-lak- of witinktplaten en 4-bit-spotlagen, en het image-woordenboek staat vanaf PDF 1.5 16 bits per component toe. De mapping in §8.9.5.2 is lineair over 0 tot 2bpc − 1, dus een 4-bit-sample van 15 is volledige sterkte; code die elke sample door 255 deelt, drukt die plaat op zo'n zes procent. Bij 16 bits is elke sample twee bytes, high byte eerst, gemapt van 0..65535 op het Decode-bereik. HotPDF decodeert Separation- en DeviceN-afbeeldingen bij 1, 2, 4, 8 en 16 bits per component met die formule
Color key-masking voegt een timingregel toe. De /Mask-array bevat 2n integers, §8.9.6.4 vergelijkt ze met de rauwe samples voordat Decode wordt toegepast, en een pixel waarvan elke component binnen zijn bereik valt wordt niet geverfd. Voor een 8-bit-afbeelding met zes inkten maskeert [0 0 0 0 0 0 0 0 0 0 0 255] elke pixel weg zonder inkt in de eerste vijf kleurcomponenten, hoe de zesde ook valt, en bij 16 bits lopen de bereiken tot 65535. De helpers hieronder volgen die leesvolgorde; elke afbeeldingsregel begint op een bytegrens:
const
MaxColorants = 32; // ISO 32000-1, bijlage C, tabel C.1
type
TColorantTints = array[0..MaxColorants - 1] of Double;
// Rauwe waarde van component C van pixel X in één regel verpakt bij 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: high byte eerst
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;
// Color key-test op rauwe samples: Mask bevat 2n integers
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;
// Lineaire Decode-mapping over 0..2^bpc - 1, één Decode-paar per kleurcomponent
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 bij 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;
Bij een 4-bit-afbeelding met zes inkten en de standaard-Decode [0 1 0 1 0 1 0 1 0 1 0 1] moet een rauwe 15 in het oranje-kanaal uit DecodePixel komen als tint 1.0. Een lezer met vier componenten zet hetzelfde nibble op een compleet ander kanaal. Pixel 1 begint op bit 24, niet op bit 16. De 16-bit-tak leest twee bytes per component, dus dezelfde pixel van een 16-bit-afbeelding begint op byte 12, en IsKeyedOut vergelijkt de volledige 16-bit-waarde met de key
Wat controleert HotPDF voordat het een zes-inkt-afbeelding decodeert?
Of de afbeelding en zijn kleurruimte het over n eens zijn. GetLoadedImageInfo meldt de kleurruimtefamilie, het componentaantal uit de names-array, de bitdiepte en een Decodable-vlag, dus een afbeelding met zes inkten meldt zich voordat er ook maar één pixel gelezen is. Een afbeelding waarvan het opgegeven componentaantal niet klopt met zijn kleurruimte wordt helemaal niet gedecodeerd, en ExtractLoadedImage geeft er nil voor terug; een gegokte stride zou alleen maar de strepen uit de proefdoos reproduceren. Een inline-afbeelding (BI … ID … EI) mag onder §8.9.7 een DeviceN-ruimte noemen uit de /ColorSpace-resources van de pagina, en HotPDF lost die naam op en leest de inline-samples bij dezelfde n. Tinttransformaties hebben één afweging. Een kubische sampled function leest vier lattice-punten per ingang, samen 4n, dus boven vier ingangen interpoleert HotPDF de sampletabel multilineair, wat 2n punten leest en de opzoekkost begrenst. Voor een transform met zes ingangen is dat 64 leesbeurten per uitgangswaarde tegen 4.096. De besparing groeit snel
var
Pdf: THotPDF;
Info: THPDFLoadedImageInfo;
Inks: THPDFAnsiStringArray;
Proof, Plate: TBitmap;
I: Integer;
begin
Pdf := THotPDF.Create(nil);
try
Pdf.LoadFromFile('carton-hexachrome.pdf');
// Welke afbeeldingen gebruiken een ruimte met veel kleurcomponenten, en zijn ze te decoderen?
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)]));
// Kleurcomponentnamen uit elke Separation / DeviceN-ruimte op pagina 1
Inks := Pdf.GetLoadedPageSpotColorants(0);
for I := 0 to High(Inks) do
Writeln('colorant on page 1: ', string(Inks[I]));
// Composietproef met overprint-simulatie, daarna één plaat op zichzelf
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;
Separation-platen en NChannel-procesnamen
Platen beslechten discussies. Als het bestand van een leverancier in hun tool anders rendert dan in die van u, is één plaat overtuigender dan een composiet: een correct gedecodeerde Orange-plaat toont de oranje artwork en niets anders, terwijl een stride-fout hem uitsmeert over naburige platen. GetLoadedPageSpotColorants meldt de namen van kleurcomponenten precies zoals elke Separation- of DeviceN-names-array ze schrijft, volgend naar XObjects, patterns, shadings en soft masks, dus een Hexachrome-ruimte levert alle zes namen op, van Cyan tot Green. Een platenlijst die procesinkten van spotinkten moet onderscheiden kan de NChannel-attributes lezen: het /Process-woordenboek noemt de procescomponenten in zijn /Components-array, en elke spotnaam krijgt zijn eigen Separation-ruimte onder /Colorants (§8.6.6.5). Geef daar de voorkeur aan boven gokken op namen als Cyan, want de specificatie laat een niet-CMYK-procescomponent elke naam dragen. Voor het composiet simuleert RenderOverprintPreview inkten die over elkaar heen drukken, en de apparaatinstellingen in CMYK-overprint-proofing en renderapparaten bepalen hoe ver die simulatie gaat
Begin met de afbeelding die strepen trekt. Zegt GetLoadedImageInfo zes componenten en stapt uw eigen decoder er vier, dan ligt het aan de stride, en een Orange-plaat gerenderd met de HotPDF Delphi PDF-component laat de leverancier zien welke pixels bij die inkt horen