classes.c14_metrics

  1import drawBot
  2from drawBot import _drawBotDrawingTool as drawBot
  3from collections import OrderedDict
  4from fontTools.ttLib import TTFont
  5from fontTools.pens.boundsPen import BoundsPen
  6from typing import List, Literal, Dict, Protocol, Optional
  7from dataclasses import dataclass
  8from lib import fonts, layout
  9from icecream import ic
 10
 11MetricName = Literal[
 12    "ascender",
 13    "capHeight",
 14    "midCapHeight",
 15    "xHeight",
 16    "midXHeight",
 17    "baseline",
 18    "descender",
 19]
 20
 21BlockMetricName = MetricName | Literal["minY", "maxY"]
 22
 23DEBUG = 0
 24DISTINCT_THRESHOLD = layout.mm(2)
 25
 26
 27def isDistinctFrom(offsetA: float, offsetB: float) -> bool:
 28    return abs(offsetA - offsetB) > DISTINCT_THRESHOLD
 29
 30
 31@dataclass
 32class MetricBlock:
 33    text: str
 34    coords: tuple[float, float, float, float]
 35    lines: List["BlockLine"]
 36
 37    def getLineByName(self, name: BlockMetricName) -> "BlockLine | None":
 38        for line in self.lines:
 39            if line.name == name:
 40                ic(line)
 41                return line
 42        return None
 43
 44
 45@dataclass
 46class BlockLine:
 47    name: MetricName
 48    y: float
 49    offset: float
 50    isDistinct: bool
 51
 52    def isIn(self, names: List[BlockMetricName]) -> bool:
 53        return self.name in names
 54
 55    def isDistinctFrom(self, other: "BlockLine") -> bool:
 56        if self.offset is None or other.offset is None:
 57            return False
 58        return isDistinctFrom(self.offset, other.offset)
 59
 60
 61# Declare external DB class shape for type checking
 62class DBBoundsItem(Protocol):
 63    """Protocol for DrawBot `textBoxCharacterBounds()` item."""
 64
 65    formattedSubString: str
 66    bounds: tuple[float, float, float, float]
 67    baselineOffset: float
 68
 69
 70class KMetrics:
 71    def __init__(self, fontPath: str, threshold: Optional[float] = None):
 72        """
 73        A class to extract and calculate key vertical metrics from a font.
 74
 75        Args:
 76            fontPath (str): Path to the font file.
 77            threshold (float): Minimum distance in points to consider two metrics as distinct, higher number means more aggressive simplification (default: 2mm).
 78        """
 79        self.fontPath = fontPath
 80        self.fontName = fonts.getFontName(fontPath)
 81        self.font = TTFont(fontPath)
 82
 83        if threshold is not None:
 84            globals()["DISTINCT_THRESHOLD"] = threshold
 85
 86        self.glyphSet = self.font.getGlyphSet()
 87        self.cmap = self.font.getBestCmap()
 88        self.unitsPerEm: float = self.font["head"].unitsPerEm
 89
 90        self.os2 = self.font["OS/2"]
 91        self.hhea = self.font["hhea"]
 92
 93        self.offsets: Dict[MetricName, float] = dict(
 94            ascender=self.os2.sTypoAscender,
 95            capHeight=self.os2.sCapHeight,
 96            midCapHeight=self.os2.sCapHeight / 2,
 97            xHeight=self.os2.sxHeight,
 98            midXHeight=self.os2.sxHeight / 2,
 99            baseline=0,
100            descender=self.os2.sTypoDescender,
101        )
102
103    def printOS2Table(self) -> None:
104        for attr in dir(self.os2):
105            if not attr.startswith("_"):
106                print(f"{attr}: {getattr(self.os2, attr)}")
107
108    @property
109    def scale(self) -> float:
110        if not hasattr(self, "_scale"):
111            raise ValueError("Scale not set. Call setScale(fontSize) first.")
112        return self._scale
113
114    @scale.setter
115    def scale(self, fontSize: float):
116        self._scale = fontSize / self.unitsPerEm
117
118    def setScale(self, fontSize: float) -> "KMetrics":
119        self.scale = fontSize
120        return self
121
122    # ? Naming distinction: offset = relative, position = absolute
123    def getOffsetYByName(self, name: MetricName) -> float:
124        """Get the scaled relative offset Y position for a given metric name."""
125        try:
126            return self.offsets[name] * self.scale
127        except KeyError:
128            raise ValueError(f"Invalid metric name: {name}")
129
130    def getOffsetExtremaForText(self, text: str) -> tuple[float | None, float | None]:
131        """Get the minimum and maximum scaled relative Y positions for the given text."""
132        min_y, max_y = None, None
133        for char in text:
134            glyph_name = self.cmap.get(ord(char))
135            if glyph_name is None:
136                if DEBUG:
137                    print(f"No {self.fontName} glyph for character '{char}'")
138                continue
139            pen = BoundsPen(self.glyphSet)
140            self.glyphSet[glyph_name].draw(pen)
141            if pen.bounds:
142                _, yMin, _, yMax = pen.bounds
143                if min_y is None or yMin < min_y:
144                    min_y = yMin
145                if max_y is None or yMax > max_y:
146                    max_y = yMax
147
148        scale = lambda v: v * self.scale if v is not None else None
149        min_y, max_y = [scale(v) for v in (min_y, max_y)]
150        return min_y, max_y
151
152    def splitIntoBlocks(self, text: str, coords: tuple):
153        def _createBlock(item: DBBoundsItem) -> MetricBlock:
154            x, blockY, w, h = item.bounds
155            blockY += item.baselineOffset
156            coords = (x, blockY, w, h)
157
158            relativeOffsets = {
159                name: self.getOffsetYByName(name) for name in self.offsets.keys()
160            }
161            minY, maxY = self.getOffsetExtremaForText(item.formattedSubString)
162            relativeOffsets["minY"] = minY
163            relativeOffsets["maxY"] = maxY
164
165            relativeOffsets = OrderedDict(
166                sorted(
167                    relativeOffsets.items(), key=lambda pair: pair[1] or 0, reverse=True
168                )
169            )
170
171            def createMetricPosition(
172                item: tuple[MetricName, float | None],
173            ) -> BlockLine:
174                name, offset = item
175
176                offsetsExceptThis = [
177                    o for n, o in relativeOffsets.items() if n != name and o is not None
178                ]
179
180                isDistinctFromOther = all(
181                    isDistinctFrom(offset, otherOffset)
182                    for otherOffset in offsetsExceptThis
183                    if offset is not None
184                )
185
186                y = blockY + offset if offset is not None else None
187
188                return BlockLine(name, y, offset, isDistinct=isDistinctFromOther)
189
190            lines: List[BlockLine] = map(createMetricPosition, relativeOffsets.items())
191
192            return MetricBlock(
193                item.formattedSubString,
194                coords,
195                lines,
196            )
197
198        DBBoundsList: List[DBBoundsItem] = drawBot.textBoxCharacterBounds(text, coords)
199        return [_createBlock(DBBoundsItem) for DBBoundsItem in DBBoundsList]
200
201    def sketchLines(
202        self, block: MetricBlock, names: List[BlockMetricName]
203    ) -> Dict[BlockMetricName, BlockLine]:
204        return {
205            line.name: line
206            for line in block.lines
207            if line.name in names and line.y is not None
208        }