Extracting text from annotated underlines

[dummifiedme]

I had written a small code for extracting highlights and images from a PDF after getting huge help here.

I was wondering if I could also add extraction of underlines as well. I figured that I can't just have the same code for type '9' as the underline must be having only 2 points as opposed to a rect in highlight (type'8')

Is there a quick way to extract underlines as well?

I will attach my code here.
It is not really neat though.

import os
import fitz
import re
import datetime 

#customization flags
add_YAML = 1 # 0 for no, 1 for yes, to add frontmatter at top
add_date = 1 # 0 for no, 1 for yes, to add dates at top
parent_bc_key = "Parent"
parent_bc_value = "Sources - Annoations"

# reading files in the folder
filelist = os.listdir()

# define date in out format
now = datetime.datetime.now()
today = now.strftime("%Y-%m-%d %H:%M")
todayLongForm = now.strftime("%dth %B %Y, %A")
time = now.strftime("%H:%M")

# write the YAML frontmatter (hidden in preview)
def YAML_writer(opened_file):
    opened_file.write("---\n")
    opened_file.write("title: Annot - {}\n".format(basename))
    opened_file.write("source: {}\n".format(doc.name))
    opened_file.write("date: {}\n".format(today))
    opened_file.write("tags: [{}]\n".format(notetags))
    opened_file.write("---\n\n")

_threshold_intersection = 0.5  # if the intersection is large enough.

# add obsidian wiki link to the page
def file_link_to_page(basename, page):
    Annot_Doc.write("\n%%[[{}.pdf#page={}]]%%\n".format(basename, (page.number+1)))


def _check_contain(r_word, points):
    """If `r_word` is contained in the rectangular area.

    The area of the intersection should be large enough compared to the
    area of the given word.

    Args:
        r_word (fitz.Rect): rectangular area of a single word.
        points (list): list of points in the rectangular area of the
            given part of a highlight.

    Returns:
        bool: whether `r_word` is contained in the rectangular area.
    """
    # `r` is mutable, so everytime a new `r` should be initiated.
    r = fitz.Quad(points).rect
    r.intersect(r_word)

    if r.get_area() >= r_word.get_area() * _threshold_intersection:
        contain = True
    else:
        contain = False
    return contain


def _extract_annot(annot, words_on_page):
    """Extract words in a given highlight.

    Args:
        annot (fitz.Annot): [description]
        words_on_page (list): [description]

    Returns:
        str: words in the entire highlight.
    """
    quad_points = annot.vertices
    quad_count = int(len(quad_points) / 4)
    sentences = ['' for i in range(quad_count)]
    for i in range(quad_count):
        points = quad_points[i * 4: i * 4 + 4]
        words = [
            w for w in words_on_page if
            _check_contain(fitz.Rect(w[:4]), points)
        ]
        sentences[i] = ' '.join(w[4] for w in words)
    sentence = ' '.join(sentences)

    return sentence

# define common tags you want in the files
notetags = "annotations, import, status/pending, type/404"
for filename in filelist: #loop though the files
    if not filename.endswith(".pdf"):
        continue #exclude files that are not PDFs
        
    # open the PDF in MuPDF
    doc = fitz.open(filename)
    print(doc.name)

    # Get the name of the file without any extensions
    basename = os.path.splitext(filename)[0]

    # Name of the folder with the files for a pdf
    foldername = "Annots - " + basename

    # create folder for the file selected if not already present
    if not os.path.isdir(foldername):
        os.makedirs(foldername)
    
    # path for the new Annot_Doc (Map of Content) file
    Annot_Doc_Path = "./" + foldername + "/Annots - " + basename + ".md"

    # open the Annot_Doc file
    Annot_Doc = open(Annot_Doc_Path, "w")
    
    # Write the front matter
    if add_YAML==1:
        YAML_writer(Annot_Doc)


    # add date at the top of the doc with location to your vault's daily note folder
    # if add_date==1:
    #     Annot_Doc.write("[[{}|{}]] | {}\n\n".format(today, todayLongForm, time))
    
    # add tags to the Annot_Doc before Header 1
    Annot_Doc.write("#source/annotes\n")

    # add Parent for BreadCrumbs
    Annot_Doc.write("{}::[[{}]]".format(parent_bc_key, parent_bc_value))

    # add title to the Annot_Doc -> Header 1
    Annot_Doc.write("# Annots - {}\n\n".format(basename))
    Annot_Doc.write("> ![info: Details]\n")
    Annot_Doc.write("> Title:: {}\n".format(basename))
    Annot_Doc.write("> Pages:: {}\n".format(doc.page_count))
    Annot_Doc.write("> PDF:: [[{}.pdf]]\n".format(basename))

    # loop to flip through pages
    for page in doc:
        wordlist = page.get_text("words")
        
        ranNum = 1
        # Loop through the annotations
        for annot in page.annots(): # take only the annotations that are comments or highlights
            
            # Data that might be useful
            text = annot.info["content"]
            createdTime = annot.info["creationDate"]
            modifiedTime = annot.info["modDate"]
            if annot.type[0] in (0, 4, 5, 8): 
                if annot.has_popup and annot.type[0]==9:
                        # highlighted text
                        extracthl = _extract_annot(annot, wordlist)
                        Annot_Doc.write("- {}".format(extracthl))
                        Annot_Doc.write("\t—*({})*\n".format((page.number+1)))
                        text_lines = text.split("\r")
                        for tl in text_lines:
                            if tl is text_lines[0]:
                                Annot_Doc.write("\n\t- > {}\n".format(tl))
                            else:
                                Annot_Doc.write("  {}\n".format(tl))

                
                if not annot.has_popup and annot.type[0]==9:
                    # highlighted text
                    extracthl = _extract_annot(annot, wordlist)
                    Annot_Doc.write("- {}".format(extracthl))
                    Annot_Doc.write("\t—*({})*\n".format((page.number+1)))

                if annot.type[0] in (4, 5):
                    zoom_x = 5.0  # horizontal zoom
                    zomm_y = 5.0  # vertical zoom
                    mat = fitz.Matrix(zoom_x, zomm_y)  # zoom factor 5 in each dimension

                    clip = fitz.Rect(annot.rect)
                    pix = page.get_pixmap(matrix=mat, clip=clip)
                    # print(annot.info)
                    pix_text = annot.info["content"]
                    # print(pix_text)
                    pix_title = pix_text.split("\r",1)[0]
                    print(pix_title)

                    pix_title_new = ""    
                    for a in pix_title:
                        if a!='#':
                          pix_title_new += a
                    
                    if pix_text =='':
                        pix_title_new = str(ranNum)
                        print(pix_title_new)
                        ranNum += 1

                    pix_title = pix_title_new

                    nameImg = "./{}/Img_P{}_{}.png".format(foldername, (page.number+1), pix_title)
                    pix.save(nameImg)
                    print(pix_title)

                    Annot_Doc.write("\n- ![[Img_P{}_{}.png]]".format((page.number+1),pix_title))
                    Annot_Doc.write("\t—*({})*\n".format((page.number+1)))
                    
                    if annot.has_popup:
                    # split the text into lines
                        text_lines = text.split("\r")
                        for tl in text_lines:
                            if tl is text_lines[0]:
                                Annot_Doc.write("\n\t- > {}\n".format(tl))
                            else:
                                Annot_Doc.write("  {}\n".format(tl))
    Annot_Doc.close()
doc.close()

[JorjMcKie]

There is no difference in the specification of highlights, underlines, strikeouts and squiggly annotations.
They all are defined by the same call pattern.
What differentiates them is only their look.
So you can simply reuse your code by opening up the set of allowed types ...

[dummifiedme]

I did. But the underlined portion never had any extracted text. Will try again.

[jhines84]

I recently started using PyMuPDF. Did you ever figured out how to extract underline texts?

[JorjMcKie]

Underlines, strikethroughs, squiggled underlines and highlights all work the same:
Take the annotation rectangle annot.rect and perform a simple page.get_text(clip=annot.rect) or even page.get_textbox(annot.rect).

That is it.
But keep in mind that the extraction method is precise: If any portion of any character is not fully covered by that rectangle, it will not be extracted. The relevant character bbox for this is defined by the respective font and may include more "headroom" than you expect.
So to be sure, enlarge the rectangle a little in every direction, e.g. use PyMuPDF's operator algebra and take page.get_textbox(annot.rect + (-2, -2, 2, 2)). The rectangle actually used here is 2 points larger in every dimension.