How to copy annotations from one page to another and resize the pdf when needed

[evansavage]

Hello, I am building a resize_pdf_pages function in python, and I have reliably been able to get the desired output, which is standardizing pages to 8.5" X 11" format. Page.show_pdf_page() made this very easy, but I am losing all annotations in the process, as this method does not preserve them. How do I both resize the pages and preserve the annotations?

I want the input and output documents to be "the same", other than resizing where needed. In the event of a page being too large, I would like the annotations to scale down with the original page, keeping their relative position to the input page. In the event of a page being too small, I do not scale the page up at all, I post it to the center of a standard 8.5" x 11" page. I would like to preserve the annotation positions relative to the original page size in this case.

Here is my current function:

def resize_pdf_pages(file_field, output_width=612, output_height=792):
    file_bytes = file_field.read()
    output_doc = fitz.open()

    with fitz.open("pdf", file_bytes) as pdf:
        for page_number in range(pdf.page_count):
            page = pdf.load_page(page_number)
            width = page.mediabox[2]
            height = page.mediabox[3]
            new_page = output_doc.new_page(width=output_width, height=output_height)

            if width == output_width and height == output_height:
                # Page dimensions already match the output size, copy the page
                new_page.show_pdf_page(new_page.rect, pdf, page_number)
            else:
                # Page needs resizing or center-justification
                if width <= output_width and height <= output_height:
                    # Page is smaller than the output size, center-justify the image
                    new_page.show_pdf_page(
                        fitz.Rect(
                            (output_width - width) / 2,
                            (output_height - height) / 2,
                            (width + output_width) / 2,
                            (height + output_height) / 2
                        ),
                        pdf, page_number, keep_proportion=True
                    )

                else:
                    # Page is larger than the output size, resize and center-justify the image
                    new_page.show_pdf_page(
                        new_page.rect,
                        pdf, page_number, keep_proportion=True
                    )

    return BytesIO(output_doc.write())

[JorjMcKie]

Let me transfer to Discussions first ...

[JorjMcKie]

Uff, this is a difficult thing to do!
The main reason is that the source page being shown inside the target page, is no longer a Page object there!
It is converted to a Form XObject - which cannot have annotations.
So, anything that aspires to resolve this, must take source page annotations and make them to target page annotations.
That wording sounds simple, but as always: the devil is in the details.

First of all - to be very clear: fields / widgets never ever can be covered, because being a PDF with fields makes you a Form PDF, and there is a central object enumerating all fields in the document. The target PDF would have to become a Form PDF, the source fields would have to be joined with any existing target fields, looking / exclusing field name duplicates ... and what not. Eek!

Second: If you do not insist to keep the target status "annotation" for a source page annotation, you can convert the source PDF to PDF via .convert_to_pdf(). This will convert annotations to normal page content.
However, you need a bit of luck here because this conversion does not alsways work. Problems may occur for incompatible fonts usually. But if it works, you are done.

Otherwise, let me think a bit more ...

[JorjMcKie]

I have been experimenting a bit meanwhile.

1. As I wrote: form fields / widgets are impossible to cover.
2. Annotations are close to being impossible because they are not part of the page itself. They have there own rectangle (which must be modified too), and, depending on the type, they have lists of points that actually define them like Ink, Line, Polygon, Highlight, Underline and more. These point lists also are defined in different ways and sometimes called /L, or /Inklist, /Quadpoints, etc. etc. These points must be converted to the new geometry as well. In addition, each annotation must be updated (.update()) to recompute the appearance stream. The latter will cause problems however, becuase you never know which software created the annotation, which regularly would cause a different appearance when PyMuPDF updates it.

So bottomline: forget it!
What you can do as a last resort:

• make a pixmap of the annot on the source page
• insert the image of the pixmap on the target page - of course transforming the original rectangle in the same way as you do for the page itself.

[zssup]

Hello, I am building a resize_pdf_pages function in python, and I have reliably been able to get the desired output, which is standardizing pages to 8.5" X 11" format. Page.show_pdf_page() made this very easy, but I am losing all annotations in the process, as this method does not preserve them. How do I both resize the pages and preserve the annotations?

I want the input and output documents to be "the same", other than resizing where needed. In the event of a page being too large, I would like the annotations to scale down with the original page, keeping their relative position to the input page. In the event of a page being too small, I do not scale the page up at all, I post it to the center of a standard 8.5" x 11" page. I would like to preserve the annotation positions relative to the original page size in this case.

Here is my current function:

def resize_pdf_pages(file_field, output_width=612, output_height=792):
    file_bytes = file_field.read()
    output_doc = fitz.open()

    with fitz.open("pdf", file_bytes) as pdf:
        for page_number in range(pdf.page_count):
            page = pdf.load_page(page_number)
            width = page.mediabox[2]
            height = page.mediabox[3]
            new_page = output_doc.new_page(width=output_width, height=output_height)

            if width == output_width and height == output_height:
                # Page dimensions already match the output size, copy the page
                new_page.show_pdf_page(new_page.rect, pdf, page_number)
            else:
                # Page needs resizing or center-justification
                if width <= output_width and height <= output_height:
                    # Page is smaller than the output size, center-justify the image
                    new_page.show_pdf_page(
                        fitz.Rect(
                            (output_width - width) / 2,
                            (output_height - height) / 2,
                            (width + output_width) / 2,
                            (height + output_height) / 2
                        ),
                        pdf, page_number, keep_proportion=True
                    )

                else:
                    # Page is larger than the output size, resize and center-justify the image
                    new_page.show_pdf_page(
                        new_page.rect,
                        pdf, page_number, keep_proportion=True
                    )

    return BytesIO(output_doc.write())

Thanks ChatGPT.
the PyPDF2 wheel can solve the problem.It can resize or scale the page with all the content and annotations.But it costs too long time when solves pdfs ,even for a pdf file just own 20 pages.Here is scale pdfs to A3 size.

from pypdf import PdfReader, PdfWriter

def scale_page_to_a3_landscape(pdf_reader, pdf_writer):
    # A3 landscape dimensions in points (1 point = 1/72 inches)
    a3_width = 1190.55 # 297mm * 72 points/inch / 25.4 mm/inch
    a3_height = 841.889  # 420mm * 72 points/inch / 25.4 mm/inch

    for i, page in enumerate(pdf_reader.pages):
        # Rotate the page if necessary to ensure it is in portrait orientation before scaling.
        rotation = page.rotation
        original_media_box = page.mediabox

        # Adjust for rotation
        if rotation % 180 != 0:
            # Swap width and height for rotated pages
            left = original_media_box.lower_left[0]
            right = original_media_box.upper_right[0]
            bottom = original_media_box.lower_left[1]
            top = original_media_box.upper_right[1]

            original_width = top - bottom  # For 90 or 270 degree rotations
            original_height = right - left  # For 90 or 270 degree rotations

            # Rotate the page to portrait orientation for scaling
            page.rotate(-rotation)
        else:
            left = original_media_box.lower_left[0]
            right = original_media_box.upper_right[0]
            bottom = original_media_box.lower_left[1]
            top = original_media_box.upper_right[1]

            original_width = right - left
            original_height = top - bottom

        # Calculate the scaling factors to fit the original page into A3 landscape
        width_scale = a3_width / original_width
        height_scale = a3_height / original_height
        scale_factor = min(width_scale, height_scale)

        # Scale the page content
        page.scale_by(scale_factor)

        # Restore the original rotation
        page.rotate(rotation)

        # Add the scaled page to the output PDF
        pdf_writer.add_page(page)

if __name__ == "__main__":
    input_pdf_path = 'input.pdf'
    output_pdf_path = 'output.pdf'

    try:
        with open(input_pdf_path, 'rb') as file:
            pdf_reader = PdfReader(file)
            pdf_writer = PdfWriter()

            scale_page_to_a3_landscape(pdf_reader, pdf_writer)

            with open(output_pdf_path, 'wb') as output_file:
                pdf_writer.write(output_file)

    except Exception as e:
        print(f"An error occurred: {e}")

I am still finding a faster way to used just for printer...
Well,it still so slow even in EDGE printer or AdobePDF printer😅

[JorjMcKie]

If you are ok with just the visual appearance of annotations (and fields), you can "bake" these objects into the pages, so they will look the same in the target page via show_pdf_page.

[JorjMcKie]

Do src.bake() before starting the iteration.
In the result - as mentioned - the annotations are visible, but will have become permanent page content.