modm_data.pdf2html.line

  1# Copyright 2022, Niklas Hauser
  2# SPDX-License-Identifier: MPL-2.0
  3
  4from functools import cached_property
  5from ..utils import Rectangle
  6from ..pdf import Character
  7
  8
  9class CharCluster:
 10    """
 11    A cluster of characters separated by less than two space-widths.
 12    These denote the use of additional white space that is not encoded in the
 13    character stream of the PDF page.
 14    """
 15
 16    def __init__(self, line: "CharLine", chars: list[Character]):
 17        self._line = line
 18        self.chars = chars
 19
 20    @cached_property
 21    def content(self) -> str:
 22        return "".join(c.char for c in self.chars)
 23
 24    @cached_property
 25    def bbox(self) -> Rectangle:
 26        return Rectangle(
 27            min(c.bbox.left for c in self.chars),
 28            min(c.bbox.bottom for c in self.chars),
 29            max(c.bbox.right for c in self.chars),
 30            max(c.bbox.top for c in self.chars),
 31        )
 32
 33
 34class CharLine:
 35    """
 36    A line of characters with super- and sub-script chars merged into.
 37    """
 38
 39    def __init__(
 40        self,
 41        page,
 42        chars: list,
 43        bottom: float,
 44        origin: float,
 45        top: float,
 46        height: float = None,
 47        rotation: int = 0,
 48        offset: float = 0,
 49        sort_origin: float = None,
 50    ):
 51        self._page = page
 52        self.chars = chars
 53        self.bottom = bottom
 54        self.origin = origin
 55        self.top = top
 56        self.height = height or (top - bottom)
 57        self.rotation = rotation
 58        self.offset = offset
 59        self._sort_origin = origin if sort_origin is None else sort_origin
 60
 61    @cached_property
 62    def bbox(self) -> Rectangle:
 63        """Bounding box of the character line"""
 64        return Rectangle(
 65            min(c.bbox.left for c in self.chars),
 66            min(c.bbox.bottom for c in self.chars),
 67            max(c.bbox.right for c in self.chars),
 68            max(c.bbox.top for c in self.chars),
 69        )
 70
 71    @cached_property
 72    def fonts(self) -> set[str]:
 73        """All font names in this character line"""
 74        return set(c.font for c in self.chars if c.font)
 75
 76    def contains_font(self, *fragments: str) -> bool:
 77        """:return: True if any fragment is part of the font names"""
 78        for fragment in fragments:
 79            if any(fragment in font for font in self.fonts):
 80                return True
 81        return False
 82
 83    @cached_property
 84    def content(self) -> str:
 85        """Text contained in the character line"""
 86        return "".join(c.char for c in self.chars)
 87
 88    def clusters(self, absolute_tolerance: float = None) -> list[CharCluster]:
 89        """Find clusters of characters in a line separated by `absolute_tolerance`."""
 90
 91        def _cluster(clusters, chars):
 92            if chars:
 93                clusters.append(CharCluster(self, chars))
 94
 95        # We want to group the chars if the space between them is > 1em
 96        if absolute_tolerance is None:
 97            absolute_tolerance = self._page._spacing["x_em"] * 1
 98        clusters = []
 99        current_chars = [self.chars[0]]
100        last_char = current_chars[0]
101        for next_char in self.chars[1:]:
102            if next_char.bbox.left - last_char.bbox.right < absolute_tolerance:
103                # Keep this char in the current cluster
104                current_chars.append(next_char)
105                if next_char.unicode not in {0x20, 0xA, 0xD}:
106                    last_char = next_char
107            else:
108                # Larger spacing detected, create a new cluster
109                _cluster(clusters, current_chars)
110                current_chars = [next_char]
111                last_char = next_char
112        _cluster(clusters, current_chars)
113
114        return clusters
115
116    def __repr__(self) -> str:
117        return f"Line({len(self.chars)})"