# ------------------------------------------------------------------------ # Copyright 2020-2022, Harald Lieder, mailto:harald.lieder@outlook.com # License: GNU AFFERO GPL 3.0, https://www.gnu.org/licenses/agpl-3.0.html # # Part of "PyMuPDF", a Python binding for "MuPDF" (http://mupdf.com), a # lightweight PDF, XPS, and E-book viewer, renderer and toolkit which is # maintained and developed by Artifex Software, Inc. https://artifex.com. # ------------------------------------------------------------------------ import math import typing import weakref try: from . import pymupdf except Exception: import pymupdf _format_g = pymupdf.format_g g_exceptions_verbose = pymupdf.g_exceptions_verbose point_like = "point_like" rect_like = "rect_like" matrix_like = "matrix_like" quad_like = "quad_like" # ByteString is gone from typing in 3.14. # collections.abc.Buffer available from 3.12 only try: ByteString = typing.ByteString except AttributeError: # pylint: disable=unsupported-binary-operation ByteString = bytes | bytearray | memoryview AnyType = typing.Any OptInt = typing.Union[int, None] OptFloat = typing.Optional[float] OptStr = typing.Optional[str] OptDict = typing.Optional[dict] OptBytes = typing.Optional[ByteString] OptSeq = typing.Optional[typing.Sequence] """ This is a collection of functions to extend PyMupdf. """ def get_text_blocks( page: pymupdf.Page, clip: rect_like = None, flags: OptInt = None, textpage: pymupdf.TextPage = None, sort: bool = False, ) -> list: """Return the text blocks on a page. Notes: Lines in a block are concatenated with line breaks. Args: flags: (int) control the amount of data parsed into the textpage. Returns: A list of the blocks. Each item contains the containing rectangle coordinates, text lines, running block number and block type. """ pymupdf.CheckParent(page) if flags is None: flags = pymupdf.TEXTFLAGS_BLOCKS tp = textpage if tp is None: tp = page.get_textpage(clip=clip, flags=flags) elif getattr(tp, "parent") != page: raise ValueError("not a textpage of this page") blocks = tp.extractBLOCKS() if textpage is None: del tp if sort: blocks.sort(key=lambda b: (b[3], b[0])) return blocks def get_text_words( page: pymupdf.Page, clip: rect_like = None, flags: OptInt = None, textpage: pymupdf.TextPage = None, sort: bool = False, delimiters=None, tolerance=3, ) -> list: """Return the text words as a list with the bbox for each word. Args: page: pymupdf.Page clip: (rect-like) area on page to consider flags: (int) control the amount of data parsed into the textpage. textpage: (pymupdf.TextPage) either passed-in or None. sort: (bool) sort the words in reading sequence. delimiters: (str,list) characters to use as word delimiters. tolerance: (float) consider words to be part of the same line if top or bottom coordinate are not larger than this. Relevant only if sort=True. Returns: Word tuples (x0, y0, x1, y1, "word", bno, lno, wno). """ def sort_words(words): """Sort words line-wise, forgiving small deviations.""" words.sort(key=lambda w: (w[3], w[0])) nwords = [] # final word list line = [words[0]] # collects words roughly in same line lrect = pymupdf.Rect(words[0][:4]) # start the line rectangle for w in words[1:]: wrect = pymupdf.Rect(w[:4]) if ( abs(wrect.y0 - lrect.y0) <= tolerance or abs(wrect.y1 - lrect.y1) <= tolerance ): line.append(w) lrect |= wrect else: line.sort(key=lambda w: w[0]) # sort words in line l-t-r nwords.extend(line) # append to final words list line = [w] # start next line lrect = wrect # start next line rect line.sort(key=lambda w: w[0]) # sort words in line l-t-r nwords.extend(line) # append to final words list return nwords pymupdf.CheckParent(page) if flags is None: flags = pymupdf.TEXTFLAGS_WORDS tp = textpage if tp is None: tp = page.get_textpage(clip=clip, flags=flags) elif getattr(tp, "parent") != page: raise ValueError("not a textpage of this page") words = tp.extractWORDS(delimiters) # if textpage was given, we subselect the words in clip if textpage is not None and clip is not None: # sub-select words contained in clip clip = pymupdf.Rect(clip) words = [ w for w in words if abs(clip & w[:4]) >= 0.5 * abs(pymupdf.Rect(w[:4])) ] if textpage is None: del tp if words and sort: # advanced sort if any words found words = sort_words(words) return words def get_sorted_text( page: pymupdf.Page, clip: rect_like = None, flags: OptInt = None, textpage: pymupdf.TextPage = None, tolerance=3, ) -> str: """Extract plain text avoiding unacceptable line breaks. Text contained in clip will be sorted in reading sequence. Some effort is also spent to simulate layout vertically and horizontally. Args: page: pymupdf.Page clip: (rect-like) only consider text inside flags: (int) text extraction flags textpage: pymupdf.TextPage tolerance: (float) consider words to be on the same line if their top or bottom coordinates do not differ more than this. Notes: If a TextPage is provided, all text is checked for being inside clip with at least 50% of its bbox. This allows to use some "global" TextPage in conjunction with sub- selecting words in parts of the defined TextPage rectangle. Returns: A text string in reading sequence. Left indentation of each line, inter-line and inter-word distances strive to reflect the layout. """ def line_text(clip, line): """Create the string of one text line. We are trying to simulate some horizontal layout here, too. Args: clip: (pymupdf.Rect) the area from which all text is being read. line: (list) word tuples (rect, text) contained in the line Returns: Text in this line. Generated from words in 'line'. Distance from predecessor is translated to multiple spaces, thus simulating text indentations and large horizontal distances. """ line.sort(key=lambda w: w[0].x0) ltext = "" # text in the line x1 = clip.x0 # end coordinate of ltext lrect = pymupdf.EMPTY_RECT() # bbox of this line for r, t in line: lrect |= r # update line bbox # convert distance to previous word to multiple spaces dist = max( int(round((r.x0 - x1) / r.width * len(t))), 0 if (x1 == clip.x0 or r.x0 <= x1) else 1, ) # number of space characters ltext += " " * dist + t # append word string x1 = r.x1 # update new end position return ltext # Extract words in correct sequence first. words = [ (pymupdf.Rect(w[:4]), w[4]) for w in get_text_words( page, clip=clip, flags=flags, textpage=textpage, sort=True, tolerance=tolerance, ) ] if not words: # no text present return "" totalbox = pymupdf.EMPTY_RECT() # area covering all text for wr, text in words: totalbox |= wr lines = [] # list of reconstituted lines line = [words[0]] # current line lrect = words[0][0] # the line's rectangle # walk through the words for wr, text in words[1:]: # start with second word w0r, _ = line[-1] # read previous word in current line # if this word matches top or bottom of the line, append it if abs(lrect.y0 - wr.y0) <= tolerance or abs(lrect.y1 - wr.y1) <= tolerance: line.append((wr, text)) lrect |= wr else: # output current line and re-initialize ltext = line_text(totalbox, line) lines.append((lrect, ltext)) line = [(wr, text)] lrect = wr # also append unfinished last line ltext = line_text(totalbox, line) lines.append((lrect, ltext)) # sort all lines vertically lines.sort(key=lambda l: (l[0].y1)) text = lines[0][1] # text of first line y1 = lines[0][0].y1 # its bottom coordinate for lrect, ltext in lines[1:]: distance = min(int(round((lrect.y0 - y1) / lrect.height)), 5) breaks = "\n" * (distance + 1) text += breaks + ltext y1 = lrect.y1 # return text in clip return text def get_textbox( page: pymupdf.Page, rect: rect_like, textpage: pymupdf.TextPage = None, ) -> str: tp = textpage if tp is None: tp = page.get_textpage() elif getattr(tp, "parent") != page: raise ValueError("not a textpage of this page") rc = tp.extractTextbox(rect) if textpage is None: del tp return rc def get_text_selection( page: pymupdf.Page, p1: point_like, p2: point_like, clip: rect_like = None, textpage: pymupdf.TextPage = None, ): pymupdf.CheckParent(page) tp = textpage if tp is None: tp = page.get_textpage(clip=clip, flags=pymupdf.TEXT_DEHYPHENATE) elif getattr(tp, "parent") != page: raise ValueError("not a textpage of this page") rc = tp.extractSelection(p1, p2) if textpage is None: del tp return rc def get_textpage_ocr( page: pymupdf.Page, flags: int = 0, language: str = "eng", dpi: int = 72, full: bool = False, tessdata: str = None, ) -> pymupdf.TextPage: """Create a Textpage from the OCR version of the page. OCR can be executed for the full page image, or (the default) only for areas that are not covered by readable digital text. Args: flags: (int) control content becoming part of the result. language: (str) specify expected language(s). Default is "eng" (English). dpi: (int) resolution in dpi, default 72. full: (bool) whether to OCR the full page, or to keep legible text tessdata: (str) path to Tesseract language data files. If None, the built-in function is used to find the path. """ pymupdf.CheckParent(page) tessdata = pymupdf.get_tessdata(tessdata) # Ensure 0xFFFD is not suppressed flags = ( flags & ~pymupdf.TEXT_USE_CID_FOR_UNKNOWN_UNICODE # pylint: disable=no-member & ~pymupdf.TEXT_USE_GID_FOR_UNKNOWN_UNICODE # pylint: disable=no-member ) def full_ocr(page, dpi, language, flags): """Perform OCR for the full page image.""" pix = page.get_pixmap(dpi=dpi) # create a 1-page PDF with an OCR text layer. ocr_pdf = pymupdf.Document( stream=pix.pdfocr_tobytes( compress=False, language=language, tessdata=tessdata, ), ) ocr_page = ocr_pdf.load_page(0) unzoom = page.rect.width / ocr_page.rect.width ctm = pymupdf.Matrix(unzoom, unzoom) * page.derotation_matrix tpage = ocr_page.get_textpage(flags=flags, matrix=ctm) # associate the textpage with the original page tpage.parent = weakref.proxy(page) return tpage def partial_ocr(page, dpi, language, flags): """Perform OCR for parts of the page without legible text. We create a temporary PDF for which we can freely redact text. """ doc = page.parent # make temporary PDF with the passed-in page temp_pdf = pymupdf.open() temp_pdf.insert_pdf(doc, from_page=page.number, to_page=page.number) temp_page = temp_pdf.load_page(0) temp_page.remove_rotation() # avoid OCR problems with rotated pages # extract text bboxes from the page tp = temp_page.get_textpage(flags=flags) blocks = tp.extractDICT()["blocks"] """ For partial OCR we need a TextPage that contains legible text only. Illegible text must be passed to the OCR engine. """ # Select spans with illegible text. If present, remove them first. fffd_spans = [ s["bbox"] for b in blocks if b["type"] == 0 for l in b["lines"] for s in l["spans"] if chr(0xFFFD) in s["text"] ] if fffd_spans: for bbox in fffd_spans: temp_page.add_redact_annot(bbox) temp_page.apply_redactions( images=pymupdf.PDF_REDACT_IMAGE_NONE, # pylint: disable=no-member graphics=pymupdf.PDF_REDACT_LINE_ART_NONE, # pylint: disable=no-member text=pymupdf.PDF_REDACT_TEXT_REMOVE, # pylint: disable=no-member ) # Extract text again, now without the unreadable spans. tp = temp_page.get_textpage(flags=flags) blocks = tp.extractDICT()["blocks"] # We also need a fresh copy of the original page. temp_pdf.insert_pdf(doc, from_page=page.number, to_page=page.number) temp_page = temp_pdf.load_page(-1) temp_page.remove_rotation() # avoid OCR problems with rotated pages span_bboxes = [ s["bbox"] for b in blocks if b["type"] == 0 for l in b["lines"] for s in l["spans"] if not chr(0xFFFD) in s["text"] ] # Remove digital text by redacting the span bboxes. # Then OCR the remainder of the page. for bbox in span_bboxes: temp_page.add_redact_annot(bbox) # only remove text, no images, no vectors temp_page.apply_redactions( images=pymupdf.PDF_REDACT_IMAGE_NONE, # pylint: disable=no-member graphics=pymupdf.PDF_REDACT_LINE_ART_NONE, # pylint: disable=no-member text=pymupdf.PDF_REDACT_TEXT_REMOVE, # pylint: disable=no-member ) pix = temp_page.get_pixmap(dpi=dpi) # matrix = pymupdf.Rect(pix.irect).torect(page.rect) # OCR the redacted page ocr_pdf = pymupdf.open( stream=pix.pdfocr_tobytes( compress=False, language=language, tessdata=tessdata, ), ) ocr_page = ocr_pdf[0] # Extend the original textpage with OCR-ed text. ocr_page.extend_textpage(tp, flags=pymupdf.TEXT_ACCURATE_BBOXES) # associate the textpage with the original page tp.parent = weakref.proxy(page) return tp # if OCR for the full page, OCR its pixmap @ desired dpi if full: return full_ocr(page, dpi, language, flags) # For partial OCR, make a normal textpage, then extend it with text that # is OCRed from the rest of page. return partial_ocr(page, dpi, language, flags) def get_text( page: pymupdf.Page, option: str = "text", *, clip: rect_like = None, flags: OptInt = None, textpage: pymupdf.TextPage = None, sort: bool = False, delimiters=None, tolerance=3, ): """Extract text from a page or an annotation. This is a unifying wrapper for various methods of the pymupdf.TextPage class. Args: option: (str) text, words, blocks, html, dict, json, rawdict, xhtml or xml. clip: (rect-like) restrict output to this area. flags: bit switches to e.g. exclude images or decompose ligatures. textpage: reuse this pymupdf.TextPage and make no new one. If specified, 'flags' and 'clip' are ignored. Returns: the output of methods get_text_words / get_text_blocks or pymupdf.TextPage methods extractText, extractHTML, extractDICT, extractJSON, extractRAWDICT, extractXHTML or etractXML respectively. Default and misspelling choice is "text". """ formats = { "text": pymupdf.TEXTFLAGS_TEXT, "html": pymupdf.TEXTFLAGS_HTML, "json": pymupdf.TEXTFLAGS_DICT, "rawjson": pymupdf.TEXTFLAGS_RAWDICT, "xml": pymupdf.TEXTFLAGS_XML, "xhtml": pymupdf.TEXTFLAGS_XHTML, "dict": pymupdf.TEXTFLAGS_DICT, "rawdict": pymupdf.TEXTFLAGS_RAWDICT, "words": pymupdf.TEXTFLAGS_WORDS, "blocks": pymupdf.TEXTFLAGS_BLOCKS, } option = option.lower() assert option in formats if option not in formats: option = "text" if flags is None: flags = formats[option] if option == "words": return get_text_words( page, clip=clip, flags=flags, textpage=textpage, sort=sort, delimiters=delimiters, ) if option == "blocks": return get_text_blocks( page, clip=clip, flags=flags, textpage=textpage, sort=sort ) if option == "text" and sort: return get_sorted_text( page, clip=clip, flags=flags, textpage=textpage, tolerance=tolerance, ) pymupdf.CheckParent(page) cb = None if option in ("html", "xml", "xhtml"): # no clipping for MuPDF functions clip = page.cropbox if clip is not None: clip = pymupdf.Rect(clip) cb = None elif type(page) is pymupdf.Page: cb = page.cropbox # pymupdf.TextPage with or without images tp = textpage #pymupdf.exception_info() if tp is None: tp = page.get_textpage(clip=clip, flags=flags) elif getattr(tp, "parent") != page: raise ValueError("not a textpage of this page") #pymupdf.log( '{option=}') if option == "json": t = tp.extractJSON(cb=cb, sort=sort) elif option == "rawjson": t = tp.extractRAWJSON(cb=cb, sort=sort) elif option == "dict": t = tp.extractDICT(cb=cb, sort=sort) elif option == "rawdict": t = tp.extractRAWDICT(cb=cb, sort=sort) elif option == "html": t = tp.extractHTML() elif option == "xml": t = tp.extractXML() elif option == "xhtml": t = tp.extractXHTML() else: t = tp.extractText(sort=sort) if textpage is None: del tp return t def getLinkDict(ln, document=None) -> dict: if isinstance(ln, pymupdf.Outline): dest = ln.destination(document) elif isinstance(ln, pymupdf.Link): dest = ln.dest else: assert 0, f'Unexpected {type(ln)=}.' nl = {"kind": dest.kind, "xref": 0} try: if hasattr(ln, 'rect'): nl["from"] = ln.rect except Exception: # This seems to happen quite often in PyMuPDF/tests. if g_exceptions_verbose >= 2: pymupdf.exception_info() pass pnt = pymupdf.Point(0, 0) if dest.flags & pymupdf.LINK_FLAG_L_VALID: pnt.x = dest.lt.x if dest.flags & pymupdf.LINK_FLAG_T_VALID: pnt.y = dest.lt.y if dest.kind == pymupdf.LINK_URI: nl["uri"] = dest.uri elif dest.kind == pymupdf.LINK_GOTO: nl["page"] = dest.page nl["to"] = pnt if dest.flags & pymupdf.LINK_FLAG_R_IS_ZOOM: nl["zoom"] = dest.rb.x else: nl["zoom"] = 0.0 elif dest.kind == pymupdf.LINK_GOTOR: nl["file"] = dest.file_spec.replace("\\", "/") nl["page"] = dest.page if dest.page < 0: nl["to"] = dest.dest else: nl["to"] = pnt if dest.flags & pymupdf.LINK_FLAG_R_IS_ZOOM: nl["zoom"] = dest.rb.x else: nl["zoom"] = 0.0 elif dest.kind == pymupdf.LINK_LAUNCH: nl["file"] = dest.file_spec.replace("\\", "/") elif dest.kind == pymupdf.LINK_NAMED: # The dicts should not have same key(s). assert not (dest.named.keys() & nl.keys()) nl.update(dest.named) if 'to' in nl: nl['to'] = pymupdf.Point(nl['to']) else: nl["page"] = dest.page return nl def getDestStr(xref: int, ddict: dict) -> str: """Calculate the PDF action string. Notes: Supports Link annotations and outline items (bookmarks). """ if not ddict: return "" str_goto = lambda a, b, c, d: f"/A<>" str_gotor1 = lambda a, b, c, d, e, f: f"/A<>>>" str_gotor2 = lambda a, b, c: f"/A<>>>" str_launch = lambda a, b: f"/A<>>>" str_uri = lambda a: f"/A<>" if type(ddict) in (int, float): dest = str_goto(xref, 0, ddict, 0) return dest d_kind = ddict.get("kind", pymupdf.LINK_NONE) if d_kind == pymupdf.LINK_NONE: return "" if ddict["kind"] == pymupdf.LINK_GOTO: d_zoom = ddict.get("zoom", 0) to = ddict.get("to", pymupdf.Point(0, 0)) d_left, d_top = to dest = str_goto(xref, d_left, d_top, d_zoom) return dest if ddict["kind"] == pymupdf.LINK_URI: dest = str_uri(pymupdf.get_pdf_str(ddict["uri"]),) return dest if ddict["kind"] == pymupdf.LINK_LAUNCH: fspec = pymupdf.get_pdf_str(ddict["file"]) dest = str_launch(fspec, fspec) return dest if ddict["kind"] == pymupdf.LINK_GOTOR and ddict["page"] < 0: fspec = pymupdf.get_pdf_str(ddict["file"]) dest = str_gotor2(pymupdf.get_pdf_str(ddict["to"]), fspec, fspec) return dest if ddict["kind"] == pymupdf.LINK_GOTOR and ddict["page"] >= 0: fspec = pymupdf.get_pdf_str(ddict["file"]) dest = str_gotor1( ddict["page"], ddict["to"].x, ddict["to"].y, ddict["zoom"], fspec, fspec, ) return dest return "" def getLinkText(page: pymupdf.Page, lnk: dict) -> str: # -------------------------------------------------------------------------- # define skeletons for /Annots object texts # -------------------------------------------------------------------------- ctm = page.transformation_matrix ictm = ~ctm r = lnk["from"] rect = _format_g(tuple(r * ictm)) annot = "" if lnk["kind"] == pymupdf.LINK_GOTO: if lnk["page"] >= 0: txt = pymupdf.annot_skel["goto1"] # annot_goto pno = lnk["page"] xref = page.parent.page_xref(pno) pnt = lnk.get("to", pymupdf.Point(0, 0)) # destination point dest_page = page.parent[pno] dest_ctm = dest_page.transformation_matrix dest_ictm = ~dest_ctm ipnt = pnt * dest_ictm annot = txt(xref, ipnt.x, ipnt.y, lnk.get("zoom", 0), rect) else: txt = pymupdf.annot_skel["goto2"] # annot_goto_n annot = txt(pymupdf.get_pdf_str(lnk["to"]), rect) elif lnk["kind"] == pymupdf.LINK_GOTOR: if lnk["page"] >= 0: txt = pymupdf.annot_skel["gotor1"] # annot_gotor pnt = lnk.get("to", pymupdf.Point(0, 0)) # destination point if type(pnt) is not pymupdf.Point: pnt = pymupdf.Point(0, 0) annot = txt( lnk["page"], pnt.x, pnt.y, lnk.get("zoom", 0), lnk["file"], lnk["file"], rect, ) else: txt = pymupdf.annot_skel["gotor2"] # annot_gotor_n annot = txt(pymupdf.get_pdf_str(lnk["to"]), lnk["file"], rect) elif lnk["kind"] == pymupdf.LINK_LAUNCH: txt = pymupdf.annot_skel["launch"] # annot_launch annot = txt(lnk["file"], lnk["file"], rect) elif lnk["kind"] == pymupdf.LINK_URI: txt = pymupdf.annot_skel["uri"] # txt = annot_uri annot = txt(lnk["uri"], rect) elif lnk["kind"] == pymupdf.LINK_NAMED: txt = pymupdf.annot_skel["named"] # annot_named lname = lnk.get("name") # check presence of key if lname is None: # if missing, fall back to alternative lname = lnk["nameddest"] annot = txt(lname, rect) if not annot: return annot # add a /NM PDF key to the object definition link_names = dict( # existing ids and their xref [(x[0], x[2]) for x in page.annot_xrefs() if x[1] == pymupdf.PDF_ANNOT_LINK] # pylint: disable=no-member ) old_name = lnk.get("id", "") # id value in the argument if old_name and (lnk["xref"], old_name) in link_names.items(): name = old_name # no new name if this is an update only else: i = 0 stem = pymupdf.TOOLS.set_annot_stem() + "-L%i" while True: name = stem % i if name not in link_names.values(): break i += 1 # add /NM key to object definition annot = annot.replace(f"/Link", f"/Link/NM({name})") return annot # ---------------------------------------------------------------------- # Name: wx.lib.colourdb.py # Purpose: Adds a bunch of colour names and RGB values to the # colour database so they can be found by name # # Author: Robin Dunn # # Created: 13-March-2001 # Copyright: (c) 2001-2017 by Total Control Software # Licence: wxWindows license # Tags: phoenix-port, unittest, documented # ---------------------------------------------------------------------- def getColorList() -> list: """ Returns a list of upper-case colour names. :rtype: list of strings """ return [name for name, r, g, b in pymupdf.colors_wx_list()] def getColorInfoList() -> list: """ Returns list of (name, red, gree, blue) tuples, where: name: upper-case color name. read, green, blue: integers in range 0..255. :rtype: list of tuples """ return pymupdf.colors_wx_list() def getColor(name: str) -> tuple: """Retrieve RGB color in PDF format by name. Returns: a triple of floats in range 0 to 1. In case of name-not-found, "white" is returned. """ return pymupdf.colors_pdf_dict().get(name.lower(), (1, 1, 1)) def getColorHSV(name: str) -> tuple: """Retrieve the hue, saturation, value triple of a color name. Returns: a triple (degree, percent, percent). If not found (-1, -1, -1) is returned. """ try: x = getColorInfoList()[getColorList().index(name.upper())] except Exception: if g_exceptions_verbose: pymupdf.exception_info() return (-1, -1, -1) r = x[1] / 255.0 g = x[2] / 255.0 b = x[3] / 255.0 cmax = max(r, g, b) V = round(cmax * 100, 1) cmin = min(r, g, b) delta = cmax - cmin if delta == 0: hue = 0 elif cmax == r: hue = 60.0 * (((g - b) / delta) % 6) elif cmax == g: hue = 60.0 * (((b - r) / delta) + 2) else: hue = 60.0 * (((r - g) / delta) + 4) H = int(round(hue)) if cmax == 0: sat = 0 else: sat = delta / cmax S = int(round(sat * 100)) return (H, S, V) def _get_font_properties(doc: pymupdf.Document, xref: int) -> tuple: fontname, ext, stype, buffer = doc.extract_font(xref) asc = 0.8 dsc = -0.2 if ext == "": return fontname, ext, stype, asc, dsc if buffer: try: font = pymupdf.Font(fontbuffer=buffer) asc = font.ascender dsc = font.descender bbox = font.bbox if asc - dsc < 1: if bbox.y0 < dsc: dsc = bbox.y0 asc = 1 - dsc except Exception: pymupdf.exception_info() asc *= 1.2 dsc *= 1.2 return fontname, ext, stype, asc, dsc if ext != "n/a": try: font = pymupdf.Font(fontname) asc = font.ascender dsc = font.descender except Exception: pymupdf.exception_info() asc *= 1.2 dsc *= 1.2 else: asc *= 1.2 dsc *= 1.2 return fontname, ext, stype, asc, dsc def _show_fz_text( text): #if mupdf_cppyy: # assert isinstance( text, cppyy.gbl.mupdf.Text) #else: # assert isinstance( text, mupdf.Text) num_spans = 0 num_chars = 0 span = text.m_internal.head while 1: if not span: break num_spans += 1 num_chars += span.len span = span.next return f'num_spans={num_spans} num_chars={num_chars}' """ Handle page labels for PDF documents. Reading ------- * compute the label of a page * find page number(s) having the given label. Writing ------- Supports setting (defining) page labels for PDF documents. A big Thank You goes to WILLIAM CHAPMAN who contributed the idea and significant parts of the following code during late December 2020 through early January 2021. """ def rule_dict(item): """Make a Python dict from a PDF page label rule. Args: item -- a tuple (pno, rule) with the start page number and the rule string like <>. Returns: A dict like {'startpage': int, 'prefix': str, 'style': str, 'firstpagenum': int}. """ # Jorj McKie, 2021-01-06 pno, rule = item rule = rule[2:-2].split("/")[1:] # strip "<<" and ">>" d = {"startpage": pno, "prefix": "", "firstpagenum": 1} skip = False for i, item in enumerate(rule): # pylint: disable=redefined-argument-from-local if skip: # this item has already been processed skip = False # deactivate skipping again continue if item == "S": # style specification d["style"] = rule[i + 1] # next item has the style skip = True # do not process next item again continue if item.startswith("P"): # prefix specification: extract the string x = item[1:].replace("(", "").replace(")", "") d["prefix"] = x continue if item.startswith("St"): # start page number specification x = int(item[2:]) d["firstpagenum"] = x return d def get_label_pno(pgNo, labels): """Return the label for this page number. Args: pgNo: page number, 0-based. labels: result of doc._get_page_labels(). Returns: The label (str) of the page number. Errors return an empty string. """ # Jorj McKie, 2021-01-06 item = [x for x in labels if x[0] <= pgNo][-1] rule = rule_dict(item) prefix = rule.get("prefix", "") style = rule.get("style", "") # make sure we start at 0 when enumerating the alphabet delta = -1 if style in ("a", "A") else 0 pagenumber = pgNo - rule["startpage"] + rule["firstpagenum"] + delta return construct_label(style, prefix, pagenumber) def construct_label(style, prefix, pno) -> str: """Construct a label based on style, prefix and page number.""" # William Chapman, 2021-01-06 n_str = "" if style == "D": n_str = str(pno) elif style == "r": n_str = integerToRoman(pno).lower() elif style == "R": n_str = integerToRoman(pno).upper() elif style == "a": n_str = integerToLetter(pno).lower() elif style == "A": n_str = integerToLetter(pno).upper() result = prefix + n_str return result def integerToLetter(i) -> str: """Returns letter sequence string for integer i.""" # William Chapman, Jorj McKie, 2021-01-06 import string ls = string.ascii_uppercase n, a = 1, i while pow(26, n) <= a: a -= int(math.pow(26, n)) n += 1 str_t = "" for j in reversed(range(n)): f, g = divmod(a, int(math.pow(26, j))) str_t += ls[f] a = g return str_t def integerToRoman(num: int) -> str: """Return roman numeral for an integer.""" # William Chapman, Jorj McKie, 2021-01-06 roman = ( (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"), (50, "L"), (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"), ) def roman_num(num): for r, ltr in roman: x, _ = divmod(num, r) yield ltr * x num -= r * x if num <= 0: break return "".join([a for a in roman_num(num)]) # ------------------------------------------------------------------- # Functions to recover the quad contained in a text extraction bbox # ------------------------------------------------------------------- def recover_bbox_quad(line_dir: tuple, span: dict, bbox: tuple) -> pymupdf.Quad: """Compute the quad located inside the bbox. The bbox may be any of the resp. tuples occurring inside the given span. Args: line_dir: (tuple) 'line["dir"]' of the owning line or None. span: (dict) the span. May be from get_texttrace() method. bbox: (tuple) the bbox of the span or any of its characters. Returns: The quad which is wrapped by the bbox. """ if line_dir is None: line_dir = span["dir"] cos, sin = line_dir bbox = pymupdf.Rect(bbox) # make it a rect if pymupdf.TOOLS.set_small_glyph_heights(): # ==> just fontsize as height d = 1 else: d = span["ascender"] - span["descender"] height = d * span["size"] # the quad's rectangle height # The following are distances from the bbox corners, at which we find the # respective quad points. The computation depends on in which quadrant the # text writing angle is located. hs = height * sin hc = height * cos if hc >= 0 and hs <= 0: # quadrant 1 ul = bbox.bl - (0, hc) ur = bbox.tr + (hs, 0) ll = bbox.bl - (hs, 0) lr = bbox.tr + (0, hc) elif hc <= 0 and hs <= 0: # quadrant 2 ul = bbox.br + (hs, 0) ur = bbox.tl - (0, hc) ll = bbox.br + (0, hc) lr = bbox.tl - (hs, 0) elif hc <= 0 and hs >= 0: # quadrant 3 ul = bbox.tr - (0, hc) ur = bbox.bl + (hs, 0) ll = bbox.tr - (hs, 0) lr = bbox.bl + (0, hc) else: # quadrant 4 ul = bbox.tl + (hs, 0) ur = bbox.br - (0, hc) ll = bbox.tl + (0, hc) lr = bbox.br - (hs, 0) return pymupdf.Quad(ul, ur, ll, lr) def recover_quad(line_dir: tuple, span: dict) -> pymupdf.Quad: """Recover the quadrilateral of a text span. Args: line_dir: (tuple) 'line["dir"]' of the owning line. span: the span. Returns: The quadrilateral enveloping the span's text. """ if type(line_dir) is not tuple or len(line_dir) != 2: raise ValueError("bad line dir argument") if type(span) is not dict: raise ValueError("bad span argument") return recover_bbox_quad(line_dir, span, span["bbox"]) def recover_line_quad(line: dict, spans: list = None) -> pymupdf.Quad: """Calculate the line quad for 'dict' / 'rawdict' text extractions. The lower quad points are those of the first, resp. last span quad. The upper points are determined by the maximum span quad height. From this, compute a rect with bottom-left in (0, 0), convert this to a quad and rotate and shift back to cover the text of the spans. Args: spans: (list, optional) sub-list of spans to consider. Returns: pymupdf.Quad covering selected spans. """ if spans is None: # no sub-selection spans = line["spans"] # all spans if len(spans) == 0: raise ValueError("bad span list") line_dir = line["dir"] # text direction cos, sin = line_dir q0 = recover_quad(line_dir, spans[0]) # quad of first span if len(spans) > 1: # get quad of last span q1 = recover_quad(line_dir, spans[-1]) else: q1 = q0 # last = first line_ll = q0.ll # lower-left of line quad line_lr = q1.lr # lower-right of line quad mat0 = pymupdf.planish_line(line_ll, line_lr) # map base line to x-axis such that line_ll goes to (0, 0) x_lr = line_lr * mat0 small = pymupdf.TOOLS.set_small_glyph_heights() # small glyph heights? h = max( [s["size"] * (1 if small else (s["ascender"] - s["descender"])) for s in spans] ) line_rect = pymupdf.Rect(0, -h, x_lr.x, 0) # line rectangle line_quad = line_rect.quad # make it a quad and: line_quad *= ~mat0 return line_quad def recover_span_quad(line_dir: tuple, span: dict, chars: list = None) -> pymupdf.Quad: """Calculate the span quad for 'dict' / 'rawdict' text extractions. Notes: There are two execution paths: 1. For the full span quad, the result of 'recover_quad' is returned. 2. For the quad of a sub-list of characters, the char quads are computed and joined. This is only supported for the "rawdict" extraction option. Args: line_dir: (tuple) 'line["dir"]' of the owning line. span: (dict) the span. chars: (list, optional) sub-list of characters to consider. Returns: pymupdf.Quad covering selected characters. """ if line_dir is None: # must be a span from get_texttrace() line_dir = span["dir"] if chars is None: # no sub-selection return recover_quad(line_dir, span) if "chars" not in span.keys(): raise ValueError("need 'rawdict' option to sub-select chars") q0 = recover_char_quad(line_dir, span, chars[0]) # quad of first char if len(chars) > 1: # get quad of last char q1 = recover_char_quad(line_dir, span, chars[-1]) else: q1 = q0 # last = first span_ll = q0.ll # lower-left of span quad span_lr = q1.lr # lower-right of span quad mat0 = pymupdf.planish_line(span_ll, span_lr) # map base line to x-axis such that span_ll goes to (0, 0) x_lr = span_lr * mat0 small = pymupdf.TOOLS.set_small_glyph_heights() # small glyph heights? h = span["size"] * (1 if small else (span["ascender"] - span["descender"])) span_rect = pymupdf.Rect(0, -h, x_lr.x, 0) # line rectangle span_quad = span_rect.quad # make it a quad and: span_quad *= ~mat0 # rotate back and shift back return span_quad def recover_char_quad(line_dir: tuple, span: dict, char: dict) -> pymupdf.Quad: """Recover the quadrilateral of a text character. This requires the "rawdict" option of text extraction. Args: line_dir: (tuple) 'line["dir"]' of the span's line. span: (dict) the span dict. char: (dict) the character dict. Returns: The quadrilateral enveloping the character. """ if line_dir is None: line_dir = span["dir"] if type(line_dir) is not tuple or len(line_dir) != 2: raise ValueError("bad line dir argument") if type(span) is not dict: raise ValueError("bad span argument") if type(char) is dict: bbox = pymupdf.Rect(char["bbox"]) elif type(char) is tuple: bbox = pymupdf.Rect(char[3]) else: raise ValueError("bad span argument") return recover_bbox_quad(line_dir, span, bbox)