Digitype

Digitize typefaces. Turn scans of typewriter type samples - dirty, skewed, at any resolution - into clean, installable monospaced fonts. Label where each character is; Digitype averages every impression, traces it, and rebuilds it.

Site: https://leonardchau.com/Digitype/ · Try it in your browser: https://leonardchau.com/Digitype/app/ · Docs: Preparing samples · User guide · How it works · Settings

Quick start

git clone https://github.com/dairyking98/Digitype
cd Digitype
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
.venv/bin/python3 -m digitype label "path/to/your/scans"

On Windows, run.bat "D:\Scans\Type Samples" sets up .venv on first run. Then open http://127.0.0.1:8770, draw a box around a line of text, type what it says, and press Regenerate.

The idea: a sinking island

Lower each letter into water a little at a time. The shoreline at each level is the letter thinned by that much. Where shore from two sides meets and goes under, it leaves a trail. The trail, plus the depth at which each point of it went under, is the letter's seed. A disc of radius = depth at every trail point gives the letter back exactly.

The seed is where the cleanup happens. Dirt barely moves the trail:

• speck and edge fuzz leave short, shallow trails, which get pruned;
• ink blobs are depth bumps on a steady stroke;
• splits as the island sinks mark junctions (the middle of k, the crotch of y), last points to go under mark stroke ends, and lakes mark counters.

Then the seeds can be standardized across the whole alphabet (one stem width, true verticals, shared baseline and x-height, shared serifs) and grown back: faithfully, or modified (lighter/bolder, more or less contrast, monoline), and exported as a font.

Pipeline

stage	module	status
glyph from a font (test input)	glyph.py	done
simulated worn impression / bad scan	raster.dirty	done
first cleanup: specks, pinholes (< a stroke), edge	raster.clean	done
sinking island: depth map + trail graph (nodes, branches)	island.sink	done
prune corner ridges / speck trails, merge split junctions	island.prune	done, tuning
seed: smoothed + simplified centerlines, linearized half-widths, nodes	seed.py	done (polylines; Bézier fit next)
grow back (discs + tapered capsules, junction fill)	grow.py	done
report PNG per letter	report.py	done
average several impressions of the same letter	regen.average	done
real scans: labelling tool, cells, baselines, averaging, .ttf export	project.py regen.py server.py web/	done
standardize across the alphabet		planned
terminal / serif styles (flat ends come back round today)		planned
export a .ttf (fontTools)	regen.write_font	done

In the browser (no install)

https://leonardchau.com/Digitype/app/ runs the same labelling tool with nothing installed: Python runs in the browser (Pyodide), and a service worker answers the page's /api/ requests with digitype/webapi.py in place of the server. The project lives in the browser's storage (or a folder picked on disk, Chrome/Edge); Download project / Open project (.zip) move it between computers. No "Add from a path" (a web page can't read paths), and Regenerate is about 1.6x slower than native. Build: python3 site/build.py (local test in site/dist/) or python3 site/build.py docs/app (what GitHub Pages serves - rebuild it whenever digitype/ changes).

Labelling tool (real scans)

run.bat "D:\Scans\Type Samples"      (Windows; first run sets up .venv)
.venv/bin/python3 -m digitype label path/to/samples [--project DIR]  (anywhere)

Opens a local page (http://127.0.0.1:8770). Every image, multi-page TIFF frame and PDF page is a page; Upload PDF / images… copies files into the project from the browser. Drag a box round a glyph and type it; type a whole run (spaces included) to split a line into fixed-pitch cells at the project's pitch. The page warns when the text can't match the ink (a missing or extra space). Baselines are automatic: letters that sit on the line give it, g j p , ( ... borrow it. Adaptive (default) fits the baseline locally along each line, so skewed or wavy lines are followed; Straight fits one tilted line per run. Tilt correction turns each sample level by its line's tilt before averaging. Shift+drag the red line to set one by hand.

Font sets: a project can hold several typefaces (the Peli scans are a different Olympia face per page). Pick the set in the top bar, + New font starts another; boxes, pitch and font name are kept per set, other sets' boxes show dimmed, and Regenerate only uses the chosen set.

Regenerate averages every sample of each character (lined up on cell and baseline, registered sub-pixel), then writes two fixed-pitch fonts to projects/<name>/out/<set>/: -Average.ttf (the averaged ink, traced) and -Seed.ttf (sunk to a seed and regrown). Results shows each glyph's average, trace and seed. Projects live in projects/ (not in git).

Try it

python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
.venv/bin/python3 -m digitype demo path/to/font.ttf kyR8 --dirty --out out

Each letter gets report_XXXX.png (input -> sinking island -> seed -> grown back vs the original, with IoU) and seed_XXXX_{clean,dirty}.json. examples/ has runs on Noto Sans Mono and FreeMono.

Where it stands (first prototype)

• Clean letters: the trail matches the strokes (k = stem + arm + leg, R, 8, e...), and FreeMono's slab serifs come out as their own short strokes. Regrown IoU about 0.87-0.93; the gap is mostly flat terminals coming back round, until terminal styles exist.
• Dirty (simulated) scans of Noto Sans Mono usually give the same seed as the clean letter; about a third of runs keep an extra junction or two. Thin faces like FreeMono keep more junk spurs. Averaging several impressions of each letter is the planned fix.
• Ink spread shows up as fatter half-widths (expected): the standardize step will take it out.