2b:null 2c:["$","title",null,{"children":"Extract Data from PDF | Tanner Hobson | Observable"}] 31:Tbb4,{ return htl.html`

1. Get OPS and ARGS from PDF.

A PDF is "just" a set of "operations" and "arguments." It's essentially a virtual machine abstracting how one would draw on an HTML canvas.

In this notebook, I simultaneously treat the operations within a PDF as each of: a number ("fn"), an opcode ("op"), and a character string ("str"/"ch"). As an example, here are a few important instructions.

${"moveTo lineTo curveTo stroke".split(" ").map((op) => SUMMARY(op))}

PDFs are weird when it comes to paths, or at least PDF.js processes paths weirdly. Paths are a collection of moveTo, lineTo, etc. Presumably, they're common enough that it makes sense to combine them into a single operation called constructPath.

${SUMMARY("constructPath")}

constructPath accepts an argument array with 3 arguments, in order: ops, args, minMax. The ops value is an array of numeric fn values for operations like moveTo and lineTo. Some examples include:

${[10, 20, 30].map((nth) => EXAMPLE("constructPath", nth))}

Two key traits of the constructPath opcode are:

The args array is the concatenated list of arguments for each opcode within the ops array.
The number of arguments for each operation in the ops array isn't defined except within the PDF.js code.

This means that, to understand the arguments to constructPath, we need to manually parse each opcode within.

For completeness, here is the set of opcodes and the length of arguments (for the opcodes I care about).

${CONSTRUCTPATHSUMMARY("rectangle x y width height")} ${CONSTRUCTPATHSUMMARY("moveTo x y")} ${CONSTRUCTPATHSUMMARY("lineTo x y")} ${CONSTRUCTPATHSUMMARY("curveTo cp1x cp1y cp2x cp2y x y")} ${CONSTRUCTPATHSUMMARY("curveTo2 cp2x cp2y x y")} ${CONSTRUCTPATHSUMMARY("curveTo3 cp1x cp1y x y")} `; // return function SUMMARY(op) { return htl.html.fragment`

${op}

${inspect({ op, fn: pdf.mapOpToFn.get(op), ch: pdf.mapFnToCh.get(pdf.mapOpToFn.get(op)), })}

`; // return } function EXAMPLE(op, nth=1) { for (let i=0, n=pdf.ops.length; i${op}

${inspect(pdf.arg[i])}

`; // return } } function CONSTRUCTPATHSUMMARY(s) { const [op, ...args] = s.split(' '); return htl.html.fragment`

${op} (fn: ${pdf.mapOpToFn.get(op)}): ${args.length} arguments

${arg} `)}

`; // return } }32:T538,pdf = { const pdfjsLib = await require(await FileAttachment("pdf.js").url()); pdfjsLib.GlobalWorkerOptions.workerSrc = await FileAttachment("pdf.worker.js").url(); const doc = await pdfjsLib.getDocument(await FileAttachment("parkmap.pdf").url()).promise; const page = await doc.getPage(1); const list = await page.getOperatorList(); const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'; const OPS = pdfjsLib.OPS; const mapFnToOp = new Map(); const mapOpToFn = new Map(); const mapFnToCh = new Map(); const mapChToFn = new Map(); for (let ops=Object.keys(OPS), i=0, n=ops.length; i mapFnToOp.get(d)); let str = ''; for (let i=0, j=0, n=fns.length; iQuerying the PDF Document

Now that we have an understanding of how the operations in a PDF document are structured, we can begin actually querying the document. Looking through some of the opcodes available to us, the save and restore opcodes seem like they could be useful.

Here, I have searched the document for all sequences that begin with a save and end with a restore. For each list of opcodes within that sequence, I've saved the first one and also tallied how many of that particular sequence I found.

The summary: ${extracts.map((d) => SUMMARY(d))}

Of particular interest to me, for this map, is the one that has a stroke command and appears the most often. ${SUMMARY(BEST())}

Here, we can see the constructPath opcode as well as the stroke opcode of interest. The constructPath can be split into its own "mini-PDF" matching the structure of our previous PDF object.

${inspect(CONSTRUCTPATHTOPDF(BEST()))} `; // return function BEST() { let best = null; outer: for (const current of extracts) { let keep = false; for (const { op } of current.extract) { if (op === "stroke") keep = true; } if (!keep) continue; if (best === null || current.count > best.count) { best = current; } } return best; } function SUMMARY({ str, extract, count }) { return htl.html.fragment`

${str}: (count: ${count})

${op}: ${inspect(arg)}

`; // return } function CONSTRUCTPATHTOPDF({ extract }) { let { arg: [cpFns, cpArgs, cpMinMax] } = extract.find((d) => d.op === "constructPath"); cpArgs = [...cpArgs]; const fns = []; const arg = []; const ops = []; let str = ''; for (let i=0, j=0, n=cpFns.length, m=cpArgs.length; i 1000) break;\n\n const match = re.exec(pdf.str);\n if (!match) break;\n\n const str = match[0];\n if (strToIndex.has(str)) {\n ++extracts[strToIndex.get(str)].count;\n continue;\n }\n strToIndex.set(str, extracts.length);\n\n const extract = EXTRACT(match.index, re.lastIndex);\n extracts.push({ str, extract, count: 1 });\n }\n\n return extracts;\n \n function OP2CH(op) {\n const fn = pdf.mapOpToFn.get(op);\n const ch = pdf.mapFnToCh.get(fn);\n return ch;\n }\n\n function EXTRACT(startIndex, endIndex) {\n const extract = [];\n for (let i=startIndex, n=endIndex; i