How do I batch-simplify (one after the other) paths of a collection of (very large) SVG files, preferably with a command-line tool on UNIX? - macos

Question

I have perhaps two thousand SVG files, obtained as a result of scanning a number of brochures to greyscale JPG, then batch-binarising them and saving to monochrome TIFF using ScanTailor, then batch-vectorising the TIFFs (using the command-line utility ImageMagick and a quick FOR loop in Fish), and finally resizing/editing them by hand in Inkscape. You can see my workflow heavily favours command-line UNIX utilities; I'll use a graphical tool if necessary, but not for repetitive tasks. If it makes any difference at all, my preferred UNIX distribution is MacOS.
What is left, at the end of this process, is a ~750KB file containing essentially a complete mathematical description of the page. Every printed letter or stroke of the pen has its own path, and (because I didn't use any sort of despeckling algorithm) so does every meaningless artifact (although I made sure to clean up the edges of every page, for workflow reasons).
Most of the scans, though, were imperfect (300 ppi when 600 or 900 ppi would have been better); the binarisation algorithm (the Otsu method) wasn't perfect either, etc. All of the imperfections added up, so in most cases the paths are rather noisy. The path representing the printed capital letter H, for example, needs only eight nodes (corners), or sixteen if it has rounded terminals (ends). I'm willing to accept more than that, because after all the system isn't perfect, but when I see thirty nodes on the H, and it has scalloped sides under magnification, my eyes start to bleed.
I know this isn't anything to worry about when the pages (rendered as PNG) reach the print shop, because the Mark 1 Eyeball will smooth everything out, but I'm too much of a perfectionist to leave it like that.
To solve the problem, I tried selecting all paths in Inkscape with Cmd/A, then using the "simplify path" command by typing Cmd/L. What I expected was that Inkscape would smooth all the paths individually; what resulted was Inkscape smoothing everything collectively into one blurry mess.
I get the result I want if I select path number one and type Cmd/L, then path number two and again Cmd/L, but a representative page has over FOUR HUNDRED paths and this kind of workflow is essentially impracticable.
I know Inkscape has a (very badly documented) command-line mode, and there might perhaps be a script available to do what needs doing, but if it exists somewhere I can't find it. An ideal solution would be to do what I described above, but programmatically (shell script?), then a FOR loop to do it on every file in the directory.

Answer 1

The basic algorithm for path simplification is not that complicated, as long as you do not need to handle curves. So one avenue could be to write a script yourself. The following is an excerpt from a node.js script I have used to simplify polygons/polylines in maps. For geojson files in the size range of up to several MB it would run in 0.1-0.2 seconds on my (old) computer.
The idea is to take the first and last points of a polyline and to measure how far the second point is removed from a line connecting the two. If it is less than a threshold (the smallest deviation from a straight line you will be able to spot), it can be safely removed, and the next middle point can be examined. If not, the point is preserved and further examinations measure the distance from a line from that point to the last.
const sqEpsilon = ... // square (!) of the minimum distance to preserve
// takes a list points in the form [[x,y],...]
function simplifyDP (points) {
const len = points.length;
const markers = new Uint8Array(len);
markers[0] = markers[len - 1] = 1;
simplifyDPStep(points, markers, 0, len - 1);
return markers.reduce((pts, m, i) => {
if (m) pts.push(points[i]);
return pts;
}, []);
}
function simplifyDPStep (points, markers, first, last) {
let maxSqDist = 0, idx;
for (let i = first + 1; i <= last - 1; i++) {
const sqDist = sqDistance(points[i], points[first], points[last]);
if (sqDist > maxSqDist) {
idx = i;
maxSqDist = sqDist;
}
}
if (maxSqDist > sqEpsilon) {
markers[idx] = 1;
simplifyDPStep(points, markers, first, idx);
simplifyDPStep(points, markers, idx, last);
}
}
function sqDistance(p, p1, p2) {
let x = p1[0],
y = p1[1];
const dx = p2[0] - x,
dy = p2[1] - y;
const dot = dx * dx + dy * dy;
if (dot > 0) {
const t = ((p[0] - x) * dx + (p[1] - y) * dy) / dot;
if (t > 1) {
x = p2[0];
y = p2[1];
} else if (t > 0) {
x += dx * t;
y += dy * t;
}
}
const cdx = p[0] - x;
const cdy = p[1] - y;
return cdx * cdx + cdy * cdy;
}