Trabajar con capas PDF usando Python

Las capas de PDF, también llamadas Grupos de Contenido Opcional (OCGs), le permiten organizar el contenido en grupos visuales separados que pueden mostrarse u ocultarse en visores de PDF compatibles. En Aspose.PDF, las operaciones de capa se construyen alrededor del Layer API.

Con Aspose.PDF for Python via .NET, puedes:

• Agregar varias capas a una página.
• Bloquee y desbloquee capas para controlar el comportamiento de visibilidad.
• Extraer capas en archivos o flujos separados.
• Aplanar contenido en capas en la página.
• Combinar varias capas en una capa.

Agregar capas a un PDF

Este ejemplo crea un PDF con tres capas. Utiliza un Document, agrega un Page, y añade Layer objetos a esa página.

1. Crear un nuevo Document y agregar un Page.
2. Crear y agregar la capa roja.
3. Crear y agregar la capa verde.
4. Crear y agregar la capa azul.
5. Guarde el documento PDF.

El PDF resultante contendrá tres capas separadas: una línea roja, una línea verde y una línea azul. Cada una puede activarse o desactivarse en los lectores de PDF que admiten contenido en capas.

import aspose.pdf as ap

def add_layers(outfile: str) -> None:
    document = ap.Document()
    page = document.pages.add()

    # Red layer
    layer = ap.Layer("oc1", "Red Line")
    layer.contents.append(ap.operators.SetRGBColorStroke(1, 0, 0))
    layer.contents.append(ap.operators.MoveTo(500, 700))
    layer.contents.append(ap.operators.LineTo(400, 700))
    layer.contents.append(ap.operators.Stroke())
    page.layers.append(layer)

    # Green layer
    layer = ap.Layer("oc2", "Green Line")
    layer.contents.append(ap.operators.SetRGBColorStroke(0, 1, 0))
    layer.contents.append(ap.operators.MoveTo(500, 750))
    layer.contents.append(ap.operators.LineTo(400, 750))
    layer.contents.append(ap.operators.Stroke())
    page.layers.append(layer)

    # Blue layer
    layer = ap.Layer("oc3", "Blue Line")
    layer.contents.append(ap.operators.SetRGBColorStroke(0, 0, 1))
    layer.contents.append(ap.operators.MoveTo(500, 800))
    layer.contents.append(ap.operators.LineTo(400, 800))
    layer.contents.append(ap.operators.Stroke())
    page.layers.append(layer)

    document.save(outfile)
    print(f"Layers added successfully. File saved at {outfile}")

Bloquear una capa PDF

Este ejemplo abre un PDF, bloquea una capa específica en la primera página y guarda el archivo actualizado.

Bloquear una capa evita que los usuarios cambien el estado de visibilidad de esa capa en los visores PDF compatibles. Las capas se acceden desde una página y se gestionan a través de la colección de capas de la página.

Métodos y propiedad disponibles:

• Layer.lock() bloquea la capa.
• Layer.unlock() desbloquea la capa.
• Layer.locked devuelve el estado actual del bloqueo.

1. Abra el documento PDF.
2. Acceda a la primera página del PDF.
3. Verifique si la página tiene capas.
4. Obtén la primera capa y bloquéala.
5. Guarda el PDF actualizado.

Si el PDF contiene capas, la primera capa se bloqueará, garantizando que su estado de visibilidad no pueda ser cambiado por el usuario. Si no se encuentran capas, se imprimirá un mensaje en su lugar.

import aspose.pdf as ap

def lock_layer(infile: str, outfile: str) -> None:
    document = ap.Document(infile)
    page = document.pages[1]

    if len(page.layers) > 0:
        layer = page.layers[0]
        layer.lock()
        document.save(outfile)
        print(f"Layer locked successfully. File saved at {outfile}")
    else:
        print("No layers found in the document.")

Extraer elementos de capa PDF

Este ejemplo usa la biblioteca Aspose.PDF for Python via .NET para extraer capas individuales de la primera página de un documento PDF y guardar cada capa como un archivo PDF separado mediante Layer.save().

Para crear un nuevo PDF a partir de una capa, se puede usar el siguiente fragmento de código:

1. Cargar el PDF Document.
2. Acceder a capas en la página 1 mediante Page.
3. Verifique si existen capas.
4. Iterar sobre las capas y guardar cada una.

import aspose.pdf as ap

def extract_layers(infile: str, outfile: str) -> None:
    document = ap.Document(infile)
    layers = document.pages[1].layers

    if len(layers) == 0:
        print("No layers found in the document.")
        return

    index = 1
    for layer in layers:
        output_file = outfile.replace(".pdf", f"{index}.pdf")
        layer.save(output_file)
        print(f"Layer {index} saved to {output_file}")
        index += 1

Es posible extraer los elementos de capa de PDF y guardarlos en una nueva secuencia de archivo PDF:

from io import FileIO
import aspose.pdf as ap

def extract_layers_stream(infile: str, outfile: str) -> None:
    document = ap.Document(infile)

    if len(document.pages[1].layers) == 0:
        print("No layers found in the document.")
        return

    layer = document.pages[1].layers[0]

    with FileIO(outfile, "wb") as output_layer:
        layer.save(output_layer)
    print(f"Layer extracted to stream: {outfile}")

Aplanar un PDF en capas

Este script usa Aspose.PDF for Python via .NET para aplanar todas las capas en la primera página de un documento PDF. El aplanado combina el contenido visual de cada capa en una capa unificada, facilitando la impresión, el intercambio o el archivado sin perder la fidelidad visual ni los datos específicos de la capa. La operación se realiza con Layer.flatten().

1. Cargue el documento PDF.
2. Acceder a las capas en la página 1.
3. Verifique si existen capas.
4. Aplana cada capa con layer.flatten(True).
5. Guarda el documento modificado.

import aspose.pdf as ap

def flatten_layers(infile: str, outfile: str) -> None:
    document = ap.Document(infile)
    layers = document.pages[1].layers

    if len(layers) == 0:
        print("No layers found in the document.")
        return

    for layer in layers:
        layer.flatten(True)

    document.save(outfile)
    print(f"Layers flattened successfully. File saved at {outfile}")

Fusionar todas las capas de un PDF en una

Este fragmento de código utiliza Aspose.PDF para combinar todas las capas de la primera página de un PDF en una única capa unificada con un nombre personalizado mediante Page.merge_layers().

1. Cargue el documento PDF.
2. Acceda a la página 1 y recupere sus capas.
3. Verifique si existen capas.
4. Definir un nuevo nombre de capa.
5. Fusiona las capas en una.
6. Guarde el documento.

import aspose.pdf as ap

def merge_layers(infile: str, outfile: str) -> None:
    document = ap.Document(infile)
    page = document.pages[1]

    if len(page.layers) == 0:
        print("No layers found in the document.")
        return

    new_layer_name = "LayerNew"
    page.merge_layers(new_layer_name)
    document.save(outfile)
    print(f"Layers merged successfully. File saved at {outfile}")

Temas de capa relacionados

• Trabajar con páginas PDF en Python
• Trabajar con tablas en PDF usando Python
• Agregar páginas PDF en Python