Issues with Word Replacement in PDFs: Top and bottom of the replaced word turn white

[amiralisam-uni]

I’m trying to replace some words in a PDF. It worked perfectly in other examples, but in one specific case, it’s not working properly. I tried making the font and the bounding box smaller, but I couldn’t figure it out.

Here’s the original document:

When I replace “Robin” with “Boris,” it looks like this:

As you can see, the top and bottom of the replaced word turn white!

Here is my code:

import re

import fitz
from fitz import Font
from thefuzz import fuzz, process


def adjust_matrix(font, bbox, text, fontsize):
    """Compute matrix performing a horizontal scale.

    Args:
        font: Font object
        bbox: bbox of the text to fill
        text: text
        fontsize: fontsize to use
    Returns:
        Horizontal scaling matrix
    """
    tl = font.text_length(text, fontsize=fontsize)
    width = bbox[2] - bbox[0]
    scale = width / tl
    return fitz.Matrix(scale, 1)


def get_fontlist(doc, page):
    """Make a dictionary for exsiting fonts."""
    flist = {}
    for f in page.get_fonts():
        # extract xref, full font name and reference name
        xref, fullname, refname = f[0], f[3], f[4]

        # subset fonts have a "+" in string position 7
        fullname = fullname[6:] if "+" in fullname else fullname
        ff = doc.extract_font(xref)  # exract font buffer
        font = fitz.Font(fontbuffer=ff[-1])

        # store reference name and the Font object
        flist[font.name] = (refname, font)
    return flist


class PDFHandler:
    """Class to handle PDFs (open pdf, extract text, edit pages)."""

    def open_pdf(self, pdf_path):
        """Open a PDF file and return the opened document object."""
        return fitz.open(pdf_path)

    def open_pdf_from_bytes(self, pdf_bytes):
        return fitz.open("pdf", stream=pdf_bytes)

    def get_page_text(self, page):
        """Get the text content of a page."""
        page.clean_contents()
        return page.get_text()

    def replace_text(self, text, old_text, new_text):
        return re.sub(
            re.escape(old_text),
            new_text,
            text,
            flags=re.IGNORECASE,
        )

    def create_doc(self, pages: list):
        """Create a Fitz document from a list of pages."""
        return fitz.Document(pages)

    def pick_font(self, fontlist, fontname):
        """Pick a font object from the fontlist based on the fontname.

        Args:
            fontlist (dict): List of fonts used on the page
            fontname (str): Name of the font to use

        Returns:
            PyMupdf Font: Font object to use in the replacement
        """
        chosen_fontname, score = process.extractOne(
            fontname, fontlist.keys(), scorer=fuzz.WRatio
        )
        if score > 70:
            return fontlist[chosen_fontname]
        else:
            return "helvetica", Font(fontname="helvetica")

    def edit_widgets(self, page, original_text, replacement_text):
        """Replace text in the widgets (fields) of the page.

        Args:
            page (pymupdf page): The page to edit.
            original_text (str): original text to replace
            replacement_text (str): replacement text
        """
        for field in page.widgets():
            field.field_value = self.replace_text(
                field.field_value, original_text, replacement_text
            )
            field.update()

    def edit_page(self, page, replacements, use_helvetica=False):
        """Edit the page with the given replacements."""
        page_fontlist = get_fontlist(page.parent, page)
        for replacement in replacements:
            original_text = replacement["original"]
            replacement_text = replacement["replacement"]
            # edit form values beforehand to avoid redacting them
            self.edit_widgets(page, original_text, replacement_text)
            # starting with this line, this follows the script
            # from https://github.com/pymupdf/PyMuPDF/discussions/3396#discussioncomment-9153529

            # get all text spans that contain the text to replace
            spans = []  # store occurences here
            for bbox in page.search_for(original_text):
                for b in page.get_text("dict", clip=bbox)["blocks"]:
                    for l in b["lines"]:
                        spans.extend(l["spans"])

            # set them to be redacted
            for s in spans:
                page.add_redact_annot(s["bbox"], cross_out=False)

            # redact the page
            page._apply_redactions(images=0, graphics=0, text=0)

            # now insert the new text
            for s in spans:
                point = fitz.Point(s["origin"])  # insertion point
                bbox_text = s["text"]  # original text (bank)
                fsize = s["size"]  # fontsize
                font = s["font"]  # font name in PDF, which we currently negate
                color = fitz.sRGB_to_pdf(s["color"])  # re-use original color
                bbox_text = self.replace_text(
                    bbox_text, original_text, replacement_text
                )
                if not use_helvetica:
                    # Pick a font from available fonts, or use default helvetica
                    fontobj_name, font_obj = self.pick_font(page_fontlist, font)

                    # compute matrix to scale text
                    matrix = adjust_matrix(font_obj, s["bbox"], bbox_text, fsize)

                    page.insert_text(
                        point,
                        bbox_text,
                        fontname=fontobj_name,
                        fontsize=fsize,
                        color=color,
                        morph=(
                            point,
                            matrix,
                        ),  # this will shrink / stretch horizontally
                    )
                else:
                    matrix = adjust_matrix(
                        fitz.Font("helvetica"), s["bbox"], bbox_text, fsize
                    )

                    page.insert_text(
                        point,
                        bbox_text,
                        fontname="helvetica",
                        fontsize=fsize,
                        color=color,
                        morph=(
                            point,
                            matrix,
                        ),  # this will shrink / stretch horizontally
                    )

        return page


if __name__ == "__main__":
    pdf_path = "newsletter.pdf"
    pdf_handler = PDFHandler()
    doc = pdf_handler.open_pdf(pdf_path)
    page = doc[0]
    for page in doc:
        edited_page = pdf_handler.edit_page(
            page, [{"original": "Robin", "replacement": "Boris"}]
        )

        # edited_page.save("edited_page.pdf")
    doc.ez_save("newsletter_replaced.pdf")

This is the original file:
newsletter.pdf

Thanks in advance for any help or idea.

[JorjMcKie]

The rectangle for defining the redaction can be as thin as needed to make sure that no unwanted text is wiped out.
The rectangle for inserting the new text however must be large enough of course. So in situations with tight interline distances, memorize the original old text bbox and use a much thinner redaction rect. For example bbox + (0, h, 0, -h) with a suitably defined h. For example h = bbox.height * 0.3. This will make the redaction rectangle thinner by 60%.

• Then execute apply redactions
• Then insert the new text in the original rectangle

[amiralisam-uni]

Thanks for the reply and the solution.
I did as you said, and it worked, but just for one of my issues, the file that I showed it before, The outcome is pretty nice, I'll send the screenshot:

I just edit the for s in spans in this way:

# set them to be redacted
for s in spans:
    h = fitz.Rect(s["bbox"]).height * 0.3
    bbox_redact = fitz.Rect(s["bbox"]) + (0, h, 0, -h)

    page.add_redact_annot(bbox_redact, cross_out=False)

But I still have problem with emails, it's not working properly on the emails.

For example, in this email:

When I try to replace anything, the whole file ruined. In this case, I tried to replace Olga with Mona:

This is the PDF:
olgaMail.pdf

Thanks for your help.