Hough Transform Line Art From Photographs
Turn a generated image into edges, vote in angle-distance space, suppress duplicate peaks, clip lines, and export an SVG composition with a complete receipt.
Hough transform line art answers how image edges can become a sparse vector composition whose strokes remain traceable to parameter-space votes. This tutorial starts with a generated matrix, exposes threshold and accumulator choices, suppresses duplicate peaks, and exports deterministic SVG lines.
Hough transform line art begins with source rights
Use a generated geometric image by default so every pixel is reproducible and free of portrait or license ambiguity. If a photograph enters the workflow, record creator, source URL, license, permitted transformation, crop, and file hash before processing. A visual abstraction can remain a derivative work even when the output contains only lines.
The Hough patent and Duda and Hart note establish primary technical context. Hough transform line art uses their parameter-space idea as an authored image-to-vector method, not as a claim that detected lines capture the subject's meaning automatically.
The generated teaching fixture processes a tiny binary matrix defined in code. It emits accumulator peaks, clipped segment parameters, and SVG. Its counts and coordinates are local fixture results, not observations from a person, photograph, camera, or production image pipeline.
If a photograph is later added, commit a low-risk authorized reference or a reproducible fetch receipt rather than relying on a local file whose origin disappears. That makes each photograph line abstraction auditable.
- The source is a generated geometric matrix with no external image rights.
- Edge threshold produces traceable coordinates.
- Peak selection and clipping create the exported composition.
| Signal | Interpretation |
|---|---|
| Pixels, edges, and clipped lines | A three-panel transformation moves from a generated geometric bitmap through edge pixels to sparse clipped vector lines. |
Build an edge field before voting
Convert the authorized image into a declared luminance space, choose analysis resolution, smooth at a named scale, and calculate edges. Canny-style processing can add non-maximum suppression and hysteresis; a simpler generated fixture may begin with an explicit binary edge matrix. Keep threshold decisions visible because they determine which structures can vote.
The original Canny paper is the primary source for that detector. Edge voting art should not call every brightness threshold a Canny detector. Name the actual operation and preserve its parameters. Show the edge image beside the source so missing contours and noise are available for art direction.
Protect negative space. More edges create more votes and often more repetitive lines, but not necessarily a clearer composition. The embroidery paths from raster images workflow offers a different route when regions and stitch direction matter more than global straight-line evidence.
Display edge orientation and magnitude as optional diagnostics. They explain why an expected contour contributed few votes without turning the final composition into a vision benchmark.
Map points into angle-distance space
Represent a line by its normal angle theta and signed distance rho from the origin. Each edge point votes for the set of parameter pairs whose lines pass through it, forming a sinusoid in the accumulator. Collinear points produce curves that intersect near a shared bin. This normal form handles vertical lines without an infinite slope.
Choose the image origin, theta interval, rho range, and bin sizes explicitly. Finer bins separate similar lines but spread votes and increase memory; coarser bins merge structures. Hough transform line art treats resolution as an artistic and numerical control, not a hidden constant. Record it in every edition receipt.
The ribbon figure shows continuous curves for explanation, while the artifact uses a finite integer grid. Its generated diagonal creates an expected local maximum. Quantization means the reconstructed line approximates the source points, so later clipping and visual review remain necessary.
Angle bins wrap, so suppression near the interval boundary must consider equivalent orientations. Otherwise one physical line can survive as two artificial peaks in the Hough line transform.
Weight votes without inventing certainty
A basic accumulator gives each edge point one vote per angle bin. Variants can weight by gradient magnitude, restrict angle around edge orientation, or sample probabilistically. Each choice changes the meaning of a peak. Start with uniform votes for an inspectable baseline, then add weights only when they support the visual thesis.
Do not convert vote count into a probability that a line is real. It is support under the chosen edge field, parameterization, resolution, and weighting. Hough transform line art should label peaks as composition candidates. Curved contours, textures, and repeated patterns may produce strong intersections that are visually unhelpful.
Normalize or compare accumulators carefully when image size or threshold changes. A fixed peak threshold across unrelated sources has no stable meaning. The local fixture keeps dimensions and edge count constant, allowing its expected peak order to be derived directly from committed input.
Accumulator saturation and integer width need explicit bounds for larger images. A visual sketch should not overflow silently when the analysis resolution increases.
The line study derives edge points, accumulator peaks, clipped endpoints, and final SVG directly from one committed binary matrix.
Runnable artifact — hough-line-art.mjs
import assert from "node:assert/strict";
const matrix=Array.from({length:9},(_,y)=>Array.from({length:9},(_,x)=>x===y?1:0)),height=matrix.length,width=matrix[0].length,points=matrix.flatMap((row,y)=>row.flatMap((value,x)=>value?[[x,y]]:[])),angles=Array.from({length:180},(_,degree)=>degree*Math.PI/180),bins=new Map();
for(const [x,y] of points)for(let index=0;index<angles.length;index++){const theta=angles[index],rho=Math.round((x*Math.cos(theta)+y*Math.sin(theta))*4)/4,key=index+":"+rho;bins.set(key,(bins.get(key)||0)+1)}
const peaks=[...bins.entries()].map(([key,votes])=>{const [angleIndex,rho]=key.split(":").map(Number);return{angleIndex,rho,votes}}).sort((a,b)=>b.votes-a.votes||a.angleIndex-b.angleIndex||a.rho-b.rho),selected=peaks[0],theta=angles[selected.angleIndex];
const clip=(theta,rho)=>{const cosine=Math.cos(theta),sine=Math.sin(theta),candidates=[];if(Math.abs(sine)>1e-9){candidates.push([0,rho/sine],[width-1,(rho-(width-1)*cosine)/sine])}if(Math.abs(cosine)>1e-9){candidates.push([rho/cosine,0],[(rho-(height-1)*sine)/cosine,height-1])}const inside=candidates.filter(([x,y])=>x>=-1e-8&&x<=width-1+1e-8&&y>=-1e-8&&y<=height-1+1e-8).map(([x,y])=>[Math.max(0,Math.min(width-1,x)),Math.max(0,Math.min(height-1,y))]);const unique=[];for(const point of inside)if(!unique.some(other=>Math.hypot(point[0]-other[0],point[1]-other[1])<1e-7))unique.push(point);return unique.slice(0,2)};
const endpoints=clip(theta,selected.rho),normalized=endpoints.map(([x,y])=>[x/(width-1),y/(height-1)]),format=value=>Number(value.toFixed(6)),svg='<svg viewBox="0 0 '+width+' '+height+'"><line x1="'+format(endpoints[0][0])+'" y1="'+format(endpoints[0][1])+'" x2="'+format(endpoints[1][0])+'" y2="'+format(endpoints[1][1])+'"/></svg>';
assert.equal(points.length,9);assert.equal(selected.votes,9);assert.equal(endpoints.length,2);assert.deepEqual(normalized.map(pair=>pair.map(format)),[[0,0],[1,1]]);assert.match(svg,/x2="8" y2="8"/);console.log(JSON.stringify({matrix,points,peak:{thetaDegrees:selected.angleIndex,rho:selected.rho,votes:selected.votes},endpoints,normalized,svg}));console.log("PASS: generated diagonal yields a traceable peak and SVG");
Run node hough-line-art.mjs. Expected receipt: PASS: generated diagonal yields a traceable peak and SVG.
- One edge point votes along a sinusoid of possible lines.
- Several compatible points intersect in one accumulator neighborhood.
- Quantization turns the continuous parameter space into finite bins.
| Signal | Interpretation |
|---|---|
| Edge points as Hough-space ribbons | Several image points become sinusoidal curves across angle-distance space, intersecting at a shared line candidate. |
Suppress duplicate peaks and choose a rhythm
Sort candidate bins by vote, accept the strongest, and suppress a neighborhood around it in angle-distance space. The neighborhood prevents many nearly identical strokes from representing one source edge. Its shape should respect angle wrapping and distance scale. Continue until a vote threshold, line count, or composition budget is reached.
Peak suppression is an art-direction control. A broad neighborhood produces sparse structural lines; a narrow one produces bundles and tonal density. Hough transform line art can intentionally retain a few parallel echoes while still rejecting accidental duplicates. Display the accumulator bars and selected neighborhoods so the choice remains legible.
The topographic contour poster article is an adjacent line-density practice with different geometry. Here, global straight lines emerge from shared edge votes. Save rejected peak reasons so later parameter changes can be compared rather than judged from screenshots alone.
Keep a small set of manually pinned peaks if the composition requires them, but label that intervention. Curation is legitimate; concealed algorithmic authorship is not.
Clip infinite lines to the image frame
A Hough peak represents an infinite line. Convert it to intersections with the rectangular image bounds, discard intersections outside edges, deduplicate corner hits, and select the two valid endpoints. Numerical tolerance matters near parallel boundaries and corners. Test horizontal, vertical, diagonal, tangent, and out-of-frame cases.
Map endpoints into the export viewBox using the same crop and aspect transform as the edge field. Image to SVG lines should not stretch because analysis and presentation dimensions differ. The artifact emits normalized endpoints, making later stroke scaling independent of pixel resolution.
Hough transform line art may shorten segments further using support intervals along the line, but that adds another threshold and gap model. Begin with frame-clipped strokes for a clear relationship between peak and output. Add probabilistic or segment-specific variants only when the composition needs them.
Clipping should produce a stable endpoint order so hashes and downstream styling remain deterministic. Sort by the dominant line direction after intersection tests.
Turn detected lines into an authored edition
Choose line count, stroke width, opacity, cap, dash, grouping, and color as separate style parameters. Consider masking lines to a silhouette, retaining frame crossings, or emphasizing a small angle family. Preserve a monochrome proof so visual hierarchy can be assessed without palette. Critical source and method information belongs in the caption and transcript, not encoded only by color.
The spiral halftone SVG transforms tone into one continuous curve, while Hough transform line art selects global straight structures. Combining both may be interesting, but one article and edition should keep one primary method. Avoid adding decorative noise that cannot be regenerated from the receipt.
Export namespaced SVG IDs, title, description, source provenance, matrix hash, edge settings, accumulator dimensions, suppression radii, selected peaks, clipping rules, and generator version. That makes each stroke traceable from artwork back to evidence.
A line's vote count can drive a bounded style parameter, yet cap the mapping so one dominant edge does not erase every quieter structural stroke.
| Peak step | Purpose |
|---|---|
| Threshold | ignore weak support |
| Local maximum | select representative bin |
| Suppression | avoid near-duplicate strokes |
| Clip | fit the image frame |
| Signal | Interpretation |
|---|---|
| Accumulator peak landscape | Accessible bar columns rise from a parameter grid, with suppressed neighboring peaks shown as outlines. |
Audit abstraction without claiming likeness
Test generated horizontal, vertical, diagonal, crossing, parallel, empty, and noisy matrices. For an authorized photograph, inspect whether the abstraction preserves the intended gesture without making unsupported recognition or likeness claims. Record composition critique separately from numeric accumulator evidence; a high-vote line is not automatically artistically important.
At article, thumbnail, print, narrow, zoomed, and high-contrast contexts, check line visibility and overflow. Hough transform line art succeeds when the edition has a deliberate rhythm and its derivation remains inspectable. The optical-flow typography article offers another image-derived practice when motion fields rather than straight structures are the subject.
Begin with the generated matrix in the runnable artifact, export one seeded study, and archive its accumulator receipt. Only then introduce an external image with complete rights and hash evidence.
Print a monochrome proof at the intended size before calling the vector edition complete. Screen antialiasing can hide dense collisions and fragile hairlines. Preserve the paper size, stroke width, scaling mode, and exported digest in the edition record; those details make a physical failure actionable instead of anecdotal. Keep the generated source matrix and selected-peak list beside it so every repair remains traceable.