Artigo Técnico

Hexachrome em Delphi: decodificando DeviceN além de 4 tintas

Uma prova Hexachrome de caixa, CMYK mais laranja e verde num único espaço /DeviceN, renderiza a foto do produto como listras diagonais em qualquer decoder que lê quatro componentes por sample. O stride certo é o comprimento do array de nomes DeviceN — seis componentes aqui — e o renderer Delphi do HotPDF o aplica a cada sample, par de Decode, color key e vértice de mesh

Quantos colorants um espaço DeviceN pode carregar?

Tantos quanto o array de nomes dele listar. Um espaço DeviceN é escrito como [/DeviceN names alternateSpace tintTransform attributes], e a ISO 32000-1 §8.6.6.5 faz desse array toda a definição da contagem de componentes: seis nomes, seis componentes, nessa ordem. O Anexo C, Tabela C.1, lista 32 componentes DeviceN entre os limites arquiteturais mínimos que leitores em conformidade devem acomodar, então um arquivo portátil fica em 32 ou menos; a ISO 32000-2 mantém o número apenas como aquela recomendação anterior. Jobs de produção ficam bem dentro disso. Hexachrome precisa de seis tintas, e um job CMYK com três spots Pantone precisa de sete. O dicionário de atributos opcional não muda a contagem também. Um espaço NChannel (PDF 1.6) adiciona as entradas /Colorants e /Process que dizem quais nomes são tintas spot e quais são componentes de processo, mas cada sample ainda carrega um valor por nome

Anatomia do espaço de cores DeviceN mostrando como o HotPDF em Delphi dimensiona samples de imagem, arrays Decode, máscaras de color key, tint transforms e paletas indexadas a partir do array de nomes
seis nomes no array DeviceN significam seis valores por pixel e dois números por tinta em Decode e Mask, antes de qualquer decodificação começar

A contagem de tintas também define o número de entradas da tint transform, a função que mapeia n tintas para o espaço alternativo na hora de exibir. A nota sobre funções Type 4 na §7.10.5 usa o Hexachrome como próprio exemplo: uma transform de seis entradas e quatro saídas amostrada em m pontos por entrada precisa de 4 × m6 valores, então com m = 16 a tabela guardaria mais de 67 milhões de números. É por isso que a maioria dos produtores escreve uma tint transform de seis tintas como um curto programa de calculadora PostScript. O que o espaço alternativo mostra, e quando um device pinta a tinta real, é onde o rendering de spot colors Separation e DeviceN entra. Tudo o que vem abaixo acontece antes. O renderer ainda está puxando números brutos do arquivo

Quais estruturas de dados são dimensionadas por n?

Toda estrutura que guarda um valor por componente, e a especificação declara o tamanho a cada vez. Um renderer com buffer fixo de quatro slots decodifica o primeiro pixel certo por acidente e todos os seguintes errado, porque a posição de leitura deriva dois componentes por sample:

EstruturaTamanho para n colorantsRegra
Sample de imagemn componentes de BitsPerComponent bits cada§8.9.2
Array /Decode2n números, um par min/max por componente§8.9.5.2
Color key /Mask2n inteiros, comparados antes da decodificação§8.9.6.4
Tabela de lookup indexada sobre DeviceNn × (hival + 1) bytes§8.6.6.3
Tiling pattern sem corn tintas na frente do nome do pattern em scn§8.7.3.3
Cor de shading (Types 1–7)n valores, ou as saídas de /Function§8.7.4.5
Vértice de mesh (Types 4–7)n valores de cor, ou um único parâmetro t quando o shading tem /Function§8.7.4.5.5 em diante

Um shading pode quebrar na função ou na mesh. Um shading axial ou radial tira a cor de /Function, que pode ser uma função com n saídas ou um array de n funções de uma saída, uma por tinta; um renderer que avalia quatro delas deixa laranja e verde em zero, e o gradiente na tampa deriva para CMYK puro. A entrada /Background também são n valores. O caso da mesh é o mais feio. Uma free-form triangle mesh empacota flag, coordenadas e cor num único bit stream por vértice, então um decoder que consome quatro valores de cor num espaço de seis tintas deixa dois sem ler, e esses viram a flag e a coordenada x do vértice seguinte. Triângulos voam para fora da página ou colapsam em lascas. A saída mostra triângulos deslocados, não cores erradas, o que manda a caçada para um bug de geometria

Layout de vértice de mesh de um shading DeviceN de seis tintas: o HotPDF lê todas as cores, leitores Delphi curtos transformam sobras na flag do próximo vértice
dois valores de cor não lidos escorregam para a flag e a coordenada do próximo vértice, então o shading mostra triângulos deslocados em vez de cores erradas

Imagens indexadas sobre uma base de seis tintas são mais leves, mas igualmente visíveis. A entrada de paleta do índice i começa no byte 6i, não no 4i, então toda entrada depois do índice 0 carrega uma mistura das tintas do vizinho. Uma paleta completa de 256 entradas sobre essa base tem 1.536 bytes. Escrita como hex string, precisa de 3.072 dígitos hex, e a §7.3.4.3 deixa whitespace entre eles e trata um dígito final ímpar como se um 0 viesse depois. O HotPDF lê paletas binárias e hex na largura real da base e faz clamp de um índice de imagem acima do hival para o hival, então um sample fora da faixa pinta a última entrada da paleta. As regras para os outros espaços de base, e para paletas cuja base se refere a si mesmas, estão em Paletas indexadas e seus espaços de cores de base

Samples sub-byte e de 16 bits, Decode e o color key

Qualquer profundidade de bits legal pode aparecer. Arquivos de embalagem carregam plates de verniz ou tinta branca de 1 bit e camadas spot de 4 bits, e o dicionário de imagem permite 16 bits por componente desde o PDF 1.5. O mapeamento na §8.9.5.2 é linear de 0 a 2bpc − 1, então um sample de 4 bits com valor 15 é intensidade total; código que divide todo sample por 255 imprime essa plate a uns seis por cento. A 16 bits cada sample são dois bytes, byte alto primeiro, mapeados de 0..65535 para a faixa Decode. O HotPDF decodifica imagens Separation e DeviceN a 1, 2, 4, 8 e 16 bits por componente com essa fórmula

A máscara de color key adiciona uma regra de timing. O array /Mask guarda 2n inteiros, a §8.9.6.4 os compara com os samples brutos antes de o Decode ser aplicado, e um pixel em que todo componente cai dentro da sua faixa não é pintado. Para uma imagem de seis tintas de 8 bits, [0 0 0 0 0 0 0 0 0 0 0 255] mascara todo pixel sem tinta nos primeiros cinco colorants, qualquer que seja o sexto, e a 16 bits as faixas vão até 65535. Os helpers abaixo seguem essa ordem de leitura; cada linha de imagem começa num limite de byte:

const
  MaxColorants = 32;                   // ISO 32000-1 Anexo C, Tabela C.1
type
  TColorantTints = array[0..MaxColorants - 1] of Double;

// Valor bruto do componente C do pixel X numa linha empacotada 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: byte alto primeiro
    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;

// Teste de color key nos samples brutos: Mask guarda 2n inteiros
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;

// Mapeamento Decode linear sobre 0..2^bpc - 1, um par Decode por colorant
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;

Com uma imagem de seis tintas de 4 bits e o Decode padrão [0 1 0 1 0 1 0 1 0 1 0 1], um 15 bruto no canal laranja deve sair do DecodePixel como tinta 1.0. Um leitor de quatro componentes põe o mesmo nibble num canal completamente diferente. O pixel 1 começa no bit 24, não no bit 16. O branch de 16 bits lê dois bytes por componente, então o mesmo pixel de uma imagem de 16 bits começa no byte 12, e o IsKeyedOut compara o valor de 16 bits completo com a chave

Layout de bits de uma linha DeviceN de seis tintas: o HotPDF em Delphi começa o pixel um no bit 24, um leitor de quatro componentes no bit 16
o pixel 1 de uma linha de seis tintas começa no bit 24, então um leitor que avança quatro componentes por sample fica duas tintas adiantado em todo pixel seguinte

O que o HotPDF verifica antes de decodificar uma imagem de seis tintas?

Se imagem e espaço de cores concordam quanto ao n. O GetLoadedImageInfo informa a família do espaço de cores, a contagem de componentes tirada do array de nomes, a profundidade de bits e uma flag Decodable, então uma imagem de seis tintas se anuncia antes de qualquer pixel ser lido. Uma imagem cuja contagem de componentes declarada discorda do espaço de cores não é decodificada de forma alguma, e o ExtractLoadedImage retorna nil para ela; um stride chutado só reproduziria as listras da prova da caixa. Uma imagem inline (BI … ID … EI) pode nomear um espaço DeviceN dos recursos /ColorSpace da página sob a §8.9.7, e o HotPDF resolve esse nome e lê os samples inline no mesmo n. Tint transforms carregam uma troca. Uma função amostrada cúbica lê quatro pontos de lattice por entrada, 4n no total, então acima de quatro entradas o HotPDF interpola a tabela de samples multilinearmente, o que lê 2n pontos e mantém o custo de lookup limitado. Para uma transform de seis entradas são 64 leituras por valor de saída contra 4,096. A economia cresce rápido

var
  Pdf: THotPDF;
  Info: THPDFLoadedImageInfo;
  Inks: THPDFAnsiStringArray;
  Proof, Plate: TBitmap;
  I: Integer;
begin
  Pdf := THotPDF.Create(nil);
  try
    Pdf.LoadFromFile('carton-hexachrome.pdf');

    // Quais imagens usam um espaço de muitos colorants, e dá para decodificá-las?
    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)]));

    // Nomes de colorants de todo espaço Separation / DeviceN na página 1
    Inks := Pdf.GetLoadedPageSpotColorants(0);
    for I := 0 to High(Inks) do
      Writeln('colorant on page 1: ', string(Inks[I]));

    // Prova composta com simulação de overprint, depois uma plate sozinha
    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;

Plates Separation e nomes de processo NChannel

Plates resolvem discussões. Quando o arquivo de um fornecedor renderiza de um jeito na ferramenta deles e de outro na sua, uma única plate convence mais que uma composta: uma plate Orange corretamente decodificada mostra a arte laranja e nada mais, enquanto um erro de stride a esfumaça pelas plates vizinhas. O GetLoadedPageSpotColorants informa os nomes de colorants como cada array de nomes Separation ou DeviceN os escreve, seguindo XObjects, patterns, shadings e soft masks, então um espaço Hexachrome contribui com todos os seis nomes, de Cyan a Green. Uma lista de plates que precisa distinguir tintas de processo de tintas spot pode ler os atributos NChannel: o dicionário /Process nomeia os componentes de processo no array /Components dele, e todo nome spot ganha o próprio espaço Separation sob /Colorants (§8.6.6.5). Prefira isso a chutar por nomes como Cyan, porque a especificação deixa um componente de processo não CMYK carregar qualquer nome. Para a composta, o RenderOverprintPreview simula tintas se imprimindo umas sobre as outras, e as configurações de device em proofing de overprint CMYK e devices de render decidem até onde essa simulação vai

Comece pela imagem que lista. Se o GetLoadedImageInfo diz seis componentes e o seu decoder avança quatro, o stride é o culpado, e uma plate Orange renderizada com o componente PDF HotPDF para Delphi mostra ao fornecedor quais pixels pertencem àquela tinta