Trabalhar com Operadores PDF em Python
Introdução aos Operadores PDF e Seu Uso
Um operador é uma palavra‑chave PDF que especifica alguma ação a ser executada, como pintar uma forma gráfica na página. Uma palavra‑chave de operador se diferencia de um objeto nomeado pela ausência de um caractere de barra inicial (2Fh). Operadores são significativos somente dentro do fluxo de conteúdo.
Um fluxo de conteúdo é um objeto de fluxo PDF cujo dados consistem em instruções que descrevem os elementos gráficos a serem pintados em uma página. Mais detalhes sobre operadores PDF podem ser encontrados no Especificação PDF.
Use esta página quando precisar de controle direto sobre fluxos de conteúdo PDF em Python, como posicionar gráficos em coordenadas exatas, encapsular alterações de estado gráfico ou remover operadores de desenho específicos de uma página.
Adicionar Imagens com Classes de Operadores
Use classes de operadores de baixo nível quando precisar posicionar o conteúdo de imagem com muita precisão em um fluxo de página PDF, sem depender de abstrações de layout de nível superior.
Este método fornece controle granular sobre o posicionamento de imagens dentro de um PDF ao manipular diretamente o fluxo de conteúdo com operadores gráficos de baixo nível. É particularmente útil quando o posicionamento preciso e a transformação de imagens são necessários, tais como:
- adicionar marcas d’água ou logotipos em locais específicos.
- sobrepor imagens ao conteúdo existente com alinhamento exato.
- implementar layouts personalizados que não são alcançáveis com abstrações de nível mais alto.
Ao usar operadores como GSave, ConcatenateMatrix, Do e GRestore, os desenvolvedores podem garantir que as imagens sejam renderizadas com precisão e sem efeitos colaterais indesejados no conteúdo de outras páginas.
- O GSave operador salva o estado gráfico atual do PDF.
- O ConcatenateMatrix (concatenate matrix) operador é usado para definir como uma imagem deve ser posicionada na página PDF.
- O Do operador desenha a imagem na página.
- O GRestore o operador restaura o estado gráfico.
Para adicionar uma imagem em um arquivo PDF:
- Abrir o Documento PDF
- Definir coordenadas de posicionamento da imagem
- Acessar a página alvo
- Carregar a imagem em um fluxo
- Salvar o estado gráfico atual
- Criar um Retângulo e Matriz de Transformação
- Aplicar a Matriz de Transformação
- Desenhar a Imagem
- Restaurar o Estado Gráfico Anterior
- Salvar o Documento PDF Modificado
O trecho de código a seguir mostra como usar os operadores PDF:
import sys
import aspose.pdf as ap
from os import path
def add_image_using_pdf_operators(infile, imagefile, outfile):
with ap.Document(infile) as document:
lower_left_x = 100
lower_left_y = 100
upper_right_x = 200
upper_right_y = 200
page = document.pages[1]
with open(imagefile, "rb") as image_stream:
page.resources.images.add(image_stream)
page.contents.append(ap.operators.GSave())
rectangle = ap.Rectangle(
lower_left_x, lower_left_y, upper_right_x, upper_right_y, True
)
matrix = ap.Matrix(
[
rectangle.urx - rectangle.llx,
0,
0,
rectangle.ury - rectangle.lly,
rectangle.llx,
rectangle.lly,
]
)
page.contents.append(ap.operators.ConcatenateMatrix(matrix))
x_image = page.resources.images[len(page.resources.images)]
page.contents.append(ap.operators.Do(x_image.name))
page.contents.append(ap.operators.GRestore())
document.save(outfile)
Desenhar XForm na Página usando Operadores
Este exemplo usou o poder dos XForms e dos operadores gráficos para reutilizar de forma eficiente o conteúdo gráfico dentro de um PDF. Ao encapsular a imagem em um XForm, ela pode ser desenhada várias vezes sem duplicar os dados da imagem, resultando em tamanhos de arquivo menores e melhor desempenho. Essa abordagem é particularmente benéfica quando:
- a mesma imagem ou gráfico precisa aparecer várias vezes em um documento.
- É necessário um controle preciso sobre a colocação e transformação de gráficos.
- A otimização do PDF para desempenho e tamanho é uma prioridade.
Ao gerenciar o estado gráfico com GSave e GRestore, e usar matrizes de transformação com ConcatenateMatrix, esta técnica garante que cada gráfico seja renderizado corretamente e de forma independente.
import sys
import aspose.pdf as ap
from os import path
def draw_xform_on_page(infile, imagefile, outfile):
with ap.Document(infile) as document:
page_contents = document.pages[1].contents
page_contents.insert(1, ap.operators.GSave())
page_contents.append(ap.operators.GRestore())
page_contents.append(ap.operators.GSave())
form = ap.XForm.create_new_form(document.pages[1], document)
document.pages[1].resources.forms.append(form)
form.contents.append(ap.operators.GSave())
form.contents.append(ap.operators.ConcatenateMatrix(200, 0, 0, 200, 0, 0))
with open(imagefile, "rb") as image_stream:
form.resources.images.add(image_stream)
x_image = form.resources.images[len(form.resources.images)]
form.contents.append(ap.operators.Do(x_image.name))
form.contents.append(ap.operators.GRestore())
# Draw XForm at (100, 500)
page_contents.append(ap.operators.GSave())
page_contents.append(ap.operators.ConcatenateMatrix(1, 0, 0, 1, 100, 500))
page_contents.append(ap.operators.Do(form.name))
page_contents.append(ap.operators.GRestore())
# Draw XForm at (100, 300)
page_contents.append(ap.operators.GSave())
page_contents.append(ap.operators.ConcatenateMatrix(1, 0, 0, 1, 100, 300))
page_contents.append(ap.operators.Do(form.name))
page_contents.append(ap.operators.GRestore())
page_contents.append(ap.operators.GRestore())
document.save(outfile)
Remover objetos gráficos usando classes de operador
O trecho de código a seguir mostra como remover gráficos. Observe que, se o arquivo PDF contiver rótulos de texto para os gráficos, eles podem permanecer no arquivo PDF ao usar esta abordagem. Portanto, procure os operadores gráficos por um método alternativo para excluir essas imagens.
import sys
import aspose.pdf as ap
from os import path
def remove_graphics_objects(infile, outfile):
with ap.Document(infile) as document:
page = document.pages[1]
# Collect operators to remove in single pass
# Operator codes: S=Stroke, h=ClosePathStroke, f=Fill'
graphics_operators = {"S", "h", "f"}
operators_to_remove = [
op for op in page.contents if str(op) in graphics_operators
]
page.contents.delete(operators_to_remove)
document.save(outfile)