Recently Written · git

src/line-boxes.ts (3681 bytes)

 // The boxes that mark a cue on the page. Pure: no DOM.
 
 import type { OcrToken, TokenSpan } from './align';
 import { isCjk } from './book-text';
 
 export type Box = OcrToken['bbox'];
 
 /** A token of punctuation or symbols only. */
 const PUNCTUATION = /^[\p{P}\p{S}]+$/u;
 
 /** A token of opening punctuation only: a bracket or a quote that opens. */
 const OPENING = /^[\p{Ps}\p{Pi}]+$/u;
 
 /**
  * True when the box of a line can grow from the edge token of the span
  * over `next`, the token before it (`back`) or after it, on the same line.
  *
  * After a letter that is not CJK, the tokens of the same word join: a
  * space, which is no token, gives the next word another word id. CJK has
  * no spaces, and its OCR words do not show where a word ends: Japanese OCR
  * can give one word for a whole line, or one for a 。 alone. So after a
  * CJK character only punctuation joins: an opening mark before the span,
  * and another mark after it. A 。 before the span ends the cue before.
  */
 function joins(edge: OcrToken, next: OcrToken | undefined, back: boolean): next is OcrToken {
   if (next === undefined || next.page !== edge.page || next.line !== edge.line) return false;
   if (!isCjk(edge.text)) {
     return (
       edge.word !== undefined &&
       next.word === edge.word &&
       (!isCjk(next.text) || PUNCTUATION.test(next.text))
     );
   }
   if (back) return OPENING.test(next.text);
   return PUNCTUATION.test(next.text) && !OPENING.test(next.text);
 }
 
 /** Grows `box` so that it holds `bbox`. */
 function grow(box: Box, bbox: Box): void {
   box.x0 = Math.min(box.x0, bbox.x0);
   box.y0 = Math.min(box.y0, bbox.y0);
   box.x1 = Math.max(box.x1, bbox.x1);
   box.y1 = Math.max(box.y1, bbox.y1);
 }
 
 /**
  * The share of the line height that pads the left and the right side of a
  * box. Tesseract symbol boxes can end some pixels before the ink of a
  * letter, more in a larger font. A quarter of the line height is about the
  * width of a word space, so the box does not reach the next word.
  */
 export const SIDE_PAD = 0.25;
 
 /**
  * `box` with `pad` pixels on each side. The left and the right side get
  * SIDE_PAD of the height of the box when that is more.
  */
 export function padBox(box: Box, pad: number): Box {
   const side = Math.max(pad, SIDE_PAD * (box.y1 - box.y0));
   return { x0: box.x0 - side, y0: box.y0 - pad, x1: box.x1 + side, y1: box.y1 + pad };
 }
 
 /**
  * One box for each text line of `span` on `page`: the union of the boxes
  * of its tokens on that line. Tokens on other pages do not count. A span of
  * an older alignment can go past the end of `tokens`: those indices do not
  * count either.
  *
  * The alignment drops punctuation, and it can drop a noisy letter at the
  * edge of a cue. So the box of a line grows to the edges of its first and
  * its last word (see `joins`).
  */
 export function lineBoxes(tokens: readonly OcrToken[], span: TokenSpan, page: number): Box[] {
   /** For each line: its box, and the first and the last token of the span on it. */
   const lines = new Map<number, { box: Box; first: number; last: number }>();
   for (let t = span.start; t < span.end; t++) {
     const token = tokens[t];
     if (!token || token.page !== page) continue;
     const line = lines.get(token.line);
     if (!line) lines.set(token.line, { box: { ...token.bbox }, first: t, last: t });
     else {
       grow(line.box, token.bbox);
       line.last = t;
     }
   }
   return [...lines.values()].map(({ box, first, last }) => {
     for (let t = first - 1; joins(tokens[first]!, tokens[t], true); t--) grow(box, tokens[t]!.bbox);
     for (let t = last + 1; joins(tokens[last]!, tokens[t], false); t++) grow(box, tokens[t]!.bbox);
     return box;
   });
 }