image¶

def threshold(self, page_dims: np.ndarray, params: np.ndarray) -> None:
    """Construct a dewarped, thresholded image using the RemappedImage class.

    Args:
        page_dims: The final (height, width) dimensions for the page layout.
        params: The optimization parameters (e.g. rotation, translation, cubic slopes).

    """
    remap = RemappedImage(
        self.stem,
        self.cv2_img,
        self.small,
        page_dims,
        params,
        config=self.config,
    )
    self.outfile = remap.threshfile

def iteratively_assemble_spans(self) -> list:
    """Assemble spans from contours; fallback to line detection if too few are found.

    First tries text contours to assemble spans. If fewer than three spans are found,
    attempts line detection (borders of a table box) rather than text detection,
    then re-assembles spans.
    """
    spans = assemble_spans(self.stem, self.small, self.pagemask, self.contour_list)
    # Retry if insufficient spans
    if len(spans) < 3:
        print(f"  detecting lines because only {len(spans)} text spans")
        self.contour_list = self.contour_info(text=False)  # lines not text
        spans = self.attempt_reassemble_spans(spans)
    return spans

def attempt_reassemble_spans(self, prev_spans: list) -> list:
    """Attempt line-based re-assembly of spans, returning whichever set is larger.

    Args:
        prev_spans: The spans identified by text contour detection.

    Returns:
        The new line-detected spans if larger in number; else the original spans.

    """
    new_spans = assemble_spans(
        self.stem,
        self.small,
        self.pagemask,
        self.contour_list,
    )
    return new_spans if len(new_spans) > len(prev_spans) else prev_spans

def resize_to_screen(self, copy: bool = False) -> np.ndarray:
    """Downsample the loaded image to fit within SCREEN_MAX_W/H if needed.

    Args:
        copy: If True, returns a copy even if no resizing is needed.

    Returns:
        A potentially resized NumPy array.
        If the image is already smaller than SCREEN_MAX_W/H,
        the same array (or its copy) is returned.

    """
    height, width = self.cv2_img.shape[:2]
    scl_x = float(width) / self.config.SCREEN_MAX_W
    scl_y = float(height) / self.config.SCREEN_MAX_H
    scl = int(np.ceil(max(scl_x, scl_y)))
    if scl > 1.0:
        inv_scl = 1.0 / scl
        img = cv2_resize(self.cv2_img, (0, 0), None, inv_scl, inv_scl, INTER_AREA)
    elif copy:
        img = self.cv2_img.copy()
    else:
        img = self.cv2_img
    return img

def calculate_page_extents(self) -> None:
    """Create a mask for the page region, ignoring margins around the edges."""
    height, width = self.small.shape[:2]
    xmin = self.config.PAGE_MARGIN_X
    ymin = self.config.PAGE_MARGIN_Y
    xmax, ymax = (width - xmin), (height - ymin)
    self.pagemask = np.zeros((height, width), dtype=np.uint8)
    rectangle(self.pagemask, (xmin, ymin), (xmax, ymax), color=255, thickness=-1)
    self.page_outline = np.array(
        [[xmin, ymin], [xmin, ymax], [xmax, ymax], [xmax, ymin]],
    )

def contour_info(self, text: bool = True) -> list[ContourInfo]:
    """Compute contour information for either text or line detection.

    Args:
        text: If True, identifies text contours; otherwise detects lines.

    Returns:
        A list of contour objects (ContourInfo instances).

    """
    c_type = "text" if text else "line"
    mask = Mask(self.stem, self.small, self.pagemask, c_type)
    return mask.contours()