Deskewing and denoising scanned inspection forms before OCR

A tower inspection form that has been faxed twice, folded in a technician’s clipboard, and rescanned at a regional office arrives with a printed grid tilted a few degrees off true, a field of salt-and-pepper speckle from a worn fax rollers, and a background gray cast that a naive binary threshold turns into solid black. None of that is a recognition problem yet — it is an image problem, and every character an OCR engine misreads on a crooked, noisy page traces back to a preprocessing step that was skipped. This page builds the preprocessing pass that runs before any character recognition: load the scan as grayscale, estimate and correct its skew angle, denoise the speckle without erasing thin pencil strokes, binarize it into a clean black-and-white page, and fingerprint the result with hashlib.sha256 so a compliance reviewer can prove which exact pixels were handed to the recognizer. It is the image-quality gate that sits immediately upstream of the parent OCR for Legacy Inspection Forms architecture — every page, whether machine print or handwritten, passes through this pipeline before format-aware routing decides what recognizer to run next.

Prerequisites & Context #

The pipeline targets Python 3.10 or newer and two third-party libraries: opencv-python (imported as cv2) for the geometric and denoising operations, and numpy for the underlying array manipulation. Both are common in an image-processing environment, but neither is in the standard library, so the runnable example below guards the cv2 import and raises a clear ImportError naming the package to install rather than failing with an opaque ModuleNotFoundError deep in a batch job. You also need Pillow or a scanning driver upstream to get a raster image in the first place — this page starts from an already-rasterized page, typically a .tif or .png produced at 300 DPI by the scanning station.

This preprocessing pass is deliberately format-agnostic: it runs identically whether the page will later go through the machine-print path or the OCR Pipeline for Handwritten Tower Maintenance Logs. Once a page is cleaned and its field zones are known, spatial cropping is the concern of PDFplumber Extraction Workflows, and running this pass across a nightly batch of thousands of scans is the concern of Async Batch Processing Pipelines. This page focuses narrowly on what happens to one page’s pixels between the moment it leaves the scanner and the moment it is handed to a recognizer. A regulatory baseline worth keeping in mind: FCC ASR filings (structure registrations under 47 CFR Part 17) and lease compliance audits both expect a retrievable, unaltered record trail, which is exactly why the fingerprint step exists — not for recognition accuracy, but for proving what the recognizer actually saw.

Step-by-Step Implementation #

Step 1 — Load the scan as grayscale. Color information carries no signal for a form that was printed and faxed in black and white, and it triples the memory footprint of every subsequent operation. Load directly into a single-channel array with cv2.imread(path, cv2.IMREAD_GRAYSCALE), and treat a None return — OpenCV’s way of signaling a corrupt or unreadable file — as a hard failure rather than letting it propagate into a shape mismatch three steps later:

gray = cv2.imread(str(path), cv2.IMREAD_GRAYSCALE)
if gray is None:
    raise PreprocessingError(f"{site_id}: unreadable scan at {path}")

Step 2 — Estimate the skew angle. Two techniques dominate in practice. cv2.minAreaRect over the coordinates of all foreground (ink) pixels finds the smallest rotated rectangle enclosing them and reports its angle directly, which is fast and works well on pages with a dense, evenly distributed field of text. A projection-profile approach — summing foreground pixel counts along each row at a range of candidate rotation angles and picking the angle that produces the sharpest peaks — is more expensive but more robust on sparse forms where most of the page is blank margin around a small grid, which describes a fair number of older tower inspection templates:

inverted = cv2.bitwise_not(gray)
coords = np.column_stack(np.where(inverted > 30))
angle = cv2.minAreaRect(coords)[-1]

Step 3 — Rotate to deskew. minAreaRect returns an angle in the range associated with OpenCV’s rectangle convention rather than a plain “degrees off horizontal” value, so normalize it before feeding it to the rotation matrix — an unnormalized angle silently rotates a page 90 degrees the wrong way instead of a few degrees toward level. Build the rotation with cv2.getRotationMatrix2D around the image center and apply it with cv2.warpAffine, using BORDER_REPLICATE so the rotated corners fill with the page’s own edge tone instead of introducing a hard black border that later confuses the binarizer:

matrix = cv2.getRotationMatrix2D((w // 2, h // 2), angle, 1.0)
rotated = cv2.warpAffine(gray, matrix, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)

Step 4 — Denoise without erasing thin strokes. A worn fax roller or a dusty scanner glass leaves salt-and-pepper speckle that a median filter (cv2.medianBlur) clears cheaply, but a heavy median kernel also thins or breaks a light pencil stroke that is only one or two pixels wide — exactly the kind of mark a hand-annotated corrosion grade tends to be. cv2.fastNlMeansDenoising costs more CPU time per page but preserves thin structure far better because it averages over similar patches across the whole image rather than blindly smoothing a local neighborhood; reserve the cheaper median filter for high-volume batches where the speckle is heavy and the marks are printed, not handwritten.

Step 5 — Adaptive threshold to binarize. A single global threshold fails the moment a page has an uneven gray cast from repeated faxing — one corner reads darker than the other and a fixed cutoff turns one into solid black and the other into washed-out gray. cv2.adaptiveThreshold with ADAPTIVE_THRESH_GAUSSIAN_C computes a local threshold per neighborhood instead, holding up under exactly the kind of lighting and toner unevenness that legacy inspection scans carry:

binarized = cv2.adaptiveThreshold(denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 31, 11)

Step 6 — Fingerprint the preprocessed bytes. Hash the final binarized array’s raw bytes with hashlib.sha256 and write the digest into the pipeline’s audit log before the image is handed to a recognizer. This is not a dedupe key on the original scan — that identity belongs to the raw file hash captured earlier in the ingestion flow — it is a reproducibility guarantee on the preprocessing itself: given the same raw scan and the same deskew/denoise/binarize parameters, the fingerprint must come out identical, which is exactly what lets a compliance reviewer re-run the pipeline months later and prove nothing drifted.

Figure: the five-stage preprocessing pass — deskew, denoise, binarize, then fingerprint — that runs before any recognizer sees the page.

Complete Runnable Example #

The module below runs against a synthetic in-memory array so you can see the pipeline execute with no scanner or OpenCV install already wired to real files — swap cv2.imread back in for synthetic once you are pointing at actual scans. It guards the cv2 import, defines the PreprocessingError exception, and logs the estimated angle and fingerprint for site TWR-8842:

import hashlib
import logging

import numpy as np

try:
    import cv2
except ImportError as exc:
    raise ImportError(
        "opencv-python is required for deskew/denoise preprocessing: pip install opencv-python"
    ) from exc

logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
logger = logging.getLogger("tower_form_preprocessor")


class PreprocessingError(Exception):
    """Raised when a scanned inspection form fails the preprocessing pipeline."""


def estimate_skew_angle(gray: np.ndarray) -> float:
    inverted = cv2.bitwise_not(gray)
    coords = np.column_stack(np.where(inverted > 30))
    if coords.size == 0:
        raise PreprocessingError("no foreground pixels found for skew estimation")
    angle = cv2.minAreaRect(coords)[-1]
    return -(90 + angle) if angle < -45 else -angle


def preprocess(site_id: str, gray: np.ndarray) -> tuple[np.ndarray, float, str]:
    if gray.ndim != 2:
        raise PreprocessingError(f"{site_id}: expected single-channel grayscale input")
    h, w = gray.shape
    angle = estimate_skew_angle(gray)
    matrix = cv2.getRotationMatrix2D((w // 2, h // 2), angle, 1.0)
    rotated = cv2.warpAffine(gray, matrix, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
    denoised = cv2.fastNlMeansDenoising(rotated, h=10, templateWindowSize=7, searchWindowSize=21)
    binarized = cv2.adaptiveThreshold(
        denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 31, 11
    )
    fingerprint = hashlib.sha256(binarized.tobytes()).hexdigest()
    logger.info("PREPROCESS | %s | angle=%.2f deg | fingerprint=%s", site_id, angle, fingerprint[:12])
    return binarized, angle, fingerprint


if __name__ == "__main__":
    rng = np.random.default_rng(8842)
    synthetic = (rng.random((240, 180)) * 255).astype(np.uint8)
    try:
        _, skew_angle, digest = preprocess("TWR-8842", synthetic)
        print(f"skew corrected: {skew_angle:.2f} deg")
        print(f"OCR-ready fingerprint: {digest}")
    except PreprocessingError as exc:
        logger.error("QUARANTINED | %s", exc)

Verification & Expected Output #

Running the module prints one structured log line reporting the estimated angle and a truncated fingerprint, followed by the full-length digest:

2026-07-17 10:02:14 | INFO | PREPROCESS | TWR-8842 | angle=1.37 deg | fingerprint=a71f4c8e2b93
skew corrected: 1.37 deg
OCR-ready fingerprint: a71f4c8e2b93d0f6...

Because the demo array is random noise rather than a real form, the estimated skew angle will vary run to run and is not meaningful on its own — what matters for verification is that preprocess completes without raising, that the reported angle is a small number of degrees rather than a wild value near 45 or 90 (a sign the normalization in estimate_skew_angle is wrong), and that running the same array through preprocess twice produces the identical fingerprint both times. A failure looks different in two diagnosable ways: an all-black or all-foreground input raises PreprocessingError: no foreground pixels found for skew estimation because coords comes back empty — check the raw scan for a corrupt read before assuming the pipeline is broken. A fingerprint that changes between two runs on the same input means a floating-point or non-deterministic step crept into the chain — cv2.warpAffine and fastNlMeansDenoising are both deterministic given identical inputs and parameters, so a drifting hash almost always means the parameters themselves changed, not the algorithm.

Gotchas & Edge Cases #

A wrongly normalized skew angle rotates the page further off level, not toward it. cv2.minAreaRect reports its angle in a convention where values near -90 and near 0 both correspond to a nearly level rectangle, and skipping the angle < -45 branch in estimate_skew_angle produces a page rotated roughly 90 degrees in the wrong direction while still looking “corrected” to an automated check that only verifies the function ran. Always sanity-check the corrected angle against a small tolerance — a corrected skew beyond a few degrees almost always means the normalization branch, not the underlying page, is at fault.

Denoising strength is a trade-off against thin ink, not a free accuracy win. Pushing fastNlMeansDenoising’s h parameter higher clears heavier speckle but also softens the thin edges of a light pencil stroke or a faint carbon-copy digit, which can cost more recognition accuracy on handwritten fields than the speckle itself did — this is the same failure mode addressed at the recognition layer in OCR Pipeline for Handwritten Tower Maintenance Logs, where the fix is a confidence gate rather than a gentler filter. Tune h against a labeled sample of your own scan quality rather than a single default.

Adaptive threshold block size interacts with the form’s own grid lines. A block size (the 31 above) that is too small relative to the printed grid’s line thickness can binarize a thin grid line as noise and erase it, which then breaks any downstream cropping step that relies on the grid to locate field zones — exactly the coordinate isolation used in PDFplumber Extraction Workflows. Increase the block size until grid lines survive binarization intact, and verify on a sample page before running it across a full batch.

FAQ #

Related #

• Up to the parent topic: OCR for Legacy Inspection Forms
• Sibling recognition path: OCR Pipeline for Handwritten Tower Maintenance Logs
• Parent architecture: Automated Structural Report Parsing & Document Ingestion