The Smell of Molten Projects in the Morning

Ed Nisley's Blog: Shop notes, electronics, firmware, machinery, 3D printing, laser cuttery, and curiosities. Contents: 100% human thinking, 0% AI slop.

Category: Photography & Images

Taking & making images.

Walkway Over the Hudson: Camera LEDs

Under the plausible assumption the security / surveillance cameras along the Walkway Over the Hudson aren’t the cheapest junk available from a randomly named Amazon seller, this came as a surprise during a recent Walkway At Night stroll:

Walkway Over the Hudson – camera LEDs

The IR LEDs emit just enough red light to be dimly visible to the human eye, but appear much brighter to a silicon detector. I think the long gap at the bottom right is a sensor of some sort, so the array of 18 LEDs has two deaders, one near death, and six more fading away.

The necklace lights on the Mid-Hudson Bridge are once again in good repair:

Mid-Hudson Bridge – 2026-04-24

They were showing fixed white light, rather than a moving color display, but it’s still a nice effect.

2026-04-27
Image Trace and Cut

Having admired the paper craft at RavensBlight and with some experience in simple paper cuttery, I had to try my hand at the Ghost Truck. Rather than using an X-Acto knife and straight edge around the perimeter, I set it up for laser cutting.

The instructions & layouts are images in PDF files, so it’s straightforward to import them into LightBurn and trace the outlines:

Ghost Truck – LightBurn vectors

Tracing produces short vectors and irregular curves:

Ghost Truck – LightBurn pre-optimize

The Optimize Shapes tool and a little manual intervention clean things up:

Ghost Truck – LightBurn post-optimize

You must manually add any cuts buried in the pattern, as in the Trailer Wheels parts shown above, so pay attention to the instructions.

Use the Move Laser tool to put the laser head at an obvious point on the layout, then skootch the printed page (in a Letter size fixture) to put that point under the beam. Repeat for another point, iterate until satisfied, then Fire The Laser:

Ghost Truck – cutout overview

Some irregularities peek around the edges:

Ghost Truck – cutout detail

On the whole, it’s much better than I could do with a knife.

Repeat for the other seven pages of parts:

Ghost Truck – Assembly

With some diligence I may have it ready for All Hallows Eve …

2026-04-17
Cheap HD USB Camera: Base Disassembly
A brace of cheap HD USB cameras may improve the scenery around here during video meetings. They were $16, marked down from an absurd $130:

HD USB Camera price history

Some poor schlubs certainly dropped more than twice the price of a Genuine Logitech camera on these critters, but a nearly total lack of demand must have had some effect.

They do take their stylin’ cues from Logitech, although the speckled pattern on a shiny plastic sheet is amusing:

HD USB Camera – styling vs Logitech C920

Unsurprisingly, the lens is fixed / manual focus. What looked like focus rings were in different positions on the two cameras:

HD USB Camera – lens focus notches

It turns out the rings were not glued in place, perhaps because they have absolutely no effect on the camera’s focus. Maybe there’s another camera model where they rotate the lens in a threaded socket, but this ain’t that.

The front panel has three pores:
- A red Power LED is always on when it’s plugged in
- A green On the air LED lights up when the camera is selected; I have no idea what the WiFi-ish glyph is supposed to represent
- The “advanced noise canceling microphone” sits behind a pore offscreen left; the claim seems dubious.
Because these may go into smaller spaces, I dismantled the base to see what was involved. Most of the screws lie underneath thin foam sheets:

HD USB Camera – ball mount interior

The lower plate has a tripod mount and a folding bracket:

HD USB Camera – baseplate interior

The camera body has a ball mount with a few degrees of movment:

HD USB Camera – ball mount detail

Reassembled and stuck inside the laser cabinet with some good double-sided foam tape, it definitely produces a better image than the previous camera:

Platform camera view

Whatever noise cancellation the mic may provide is irrelevant in there: nobody’s listening.
2026-02-17
Most Disappointed Squirrel Ever

A motivated squirrel can climb eight feet up a galvanized steel pipe:

Squirrel atop WS-5000 Weather Station

The anemometer on the right has a ring of sharp wires intended to deter birds:

Weather station with additional spikes

Chickadees can perch between the wires and squirrels apparently just ignore the sharp ends:

Squirrel on WS-5000 Anemometer spikes

No matter how hard that squirrel looked, there were no nuts to be found anywhere in that tree. Moments later it ran down the pole and loped across the yard to forage under the seed feeder.

The terrible picture quality comes from a Pixel 6a phone camera zoomed all the way tight. I want an optical telephoto lens built into the phone, but those phones seem intended to reduce the risks of having severe wallet overpressure.

2026-01-14
Hawk With Snake

Do you see the Cooper’s Hawk?

Hawk with snake 2025-11-04 – 082

Neither did I!

(The last three digits in the caption tick along at 60 frame/s. Opening each iamge in a new tab will let you embiggen the details, although the images aren’t all that great.)

The second wingbeat, over on the left, is more visible as the hawk lifts off:

Hawk with snake 2025-11-04 – 112

This was about when I figured out what was going on:

Hawk with snake 2025-11-04 – 151

A hawk can easily outfly me!

Hawk with snake 2025-11-04 – 207

The snake dangling from the hawk’s talons didn’t see it coming, either:

Hawk with snake 2025-11-04 – 213

Up and away!

Hawk with snake 2025-11-04 – 225

About 2.3 s of elapsed time: plenty for a hawk and not nearly enough for me. Or the snake, for that matter.

2025-11-05
Mostly Removing Acrylic Scratches
Some time ago I made a simple guide / carrier to help select & arrange smashed glass fragments to fit within a given diameter:

Coaster Layout – selected fragments

The laser-engraved guide lines confused GIMP’s edge detection to no end.

It came from a large sheet of 1 mm acrylic, formerly a poster cover, bearing scars of its long history in the “might be useful someday” stash. I wondered if I could remove enough scratches and scuffs to ease GIMP’s workload.

Stipulated: I am a cheapskate.

Laser-cut a suitable sheet and sand both sides with 220 grit paper to what looked like a uniform surface:

Acrylic polishing – 220

Continue scrubbing with 400, 800, 1000, 1500, and 3000 grit papers:

Acrylic polishing – 3000

Massage it with Novus Polish 3, 2, and 1:

Acrylic polishing – Novus 1

At best, it’s more translucent than transparent and definitely not an optical-quality polishing job:

Acrylic polishing – translucency

Fortunately, I need not care about the edges, because it goes in a square frame with a circular cutout.

Tape it into that cardboard frame, scan it against a black background, and blow out the contrast to show I should have started with 100 grit paper and paid more attention to that “uniform surface” thing:

Acrylic polishing – scratches

In use, though, it doesn’t look all that bad:

Fragment layout – 5in Set B – scan tweaked

Come to find out those glittery cracks between all the cuboids still confuse GIMP’s edge detection, but at least hand-tracing the outline is easier without all the lines.

The entire “polishing” series as a slideshow for your amusement:
Acrylic polishing – 220
Acrylic polishing – 400
Acrylic polishing – 800
Acrylic polishing – 1000
Acrylic polishing – 1500
Acrylic polishing – 3000
Acrylic polishing – Novus 3
Acrylic polishing – Novus 2
Acrylic polishing – Novus 1
FWIW, those fragments turned out nicely:

Smashed Glass 3D Printed Coaster – Set B

More on that later …
2025-10-03

Layered Paper: SVG Generator

Changing the formula generating the matrix values and cleaning up some infelicitous code choices produces a much more pleasing result:

Layered paper - circular rainbow — Layered paper – circular rainbow

The random squares still look OK, though:

Layered Paper - SVG generator results — Layered Paper – SVG generator results

Thresholding the distance from a randomly chosen point creates circular rainbows:

CenterPoint = (choice(range(args.width)),choice(range(args.height)))

CellMatrix = [[math.hypot(x - CenterPoint[X],y - CenterPoint[Y])
                for y in range(args.height)]
                for x in range(args.width)]

dmax = max(list(chain.from_iterable(CellMatrix)))

LayerThreshold = (ThisLayer/Layers)*dmax

The Python program generates one SVG image file representing a single layer, as determined by the Bash one-liner invoking it:

for i in {00..16} ; do python Layers\ -\ 200mm.py > Test_$i.svg ; done

In real life you’d also use a different random seed for each set of layers, but that’s just another command line optIon.

Import those 17 SVG images into LightBurn, arrange neatly, snap each one to the middle of the workspace grid (and thus the aligned template), then Fire The Laser:

Layered Blocks - circular colors - 200mm 16x16 - LightBurn layout — Layered Blocks – circular colors – 200mm 16×16 – LightBurn layout

Feeding paper into the laser in rainbow (actually, heavily augmented / infilled EIA color code) order, plus the black mask, produces the aforementioned pleasing result:

Layered Paper - rainbow oblique view — Layered Paper – rainbow oblique view

Glue the sheets in the assembly fixture:

Layered Paper - gluing fixture side view — Layered Paper – gluing fixture side view

The white layer is uncut, other than the four alignment holes (with a rivnut poking up) and its binary layer number (16, backwards because upside-down), and appears in only the farthest corners of the rainbow.

Protip: doing the stack upside-down means you smear glue stick on the hidden side of each sheet. If you avoid slobbering glue into the cut square holes, nothing can go wrong.

Making these things produces the happiest chip tray ever:

Layered Paper - rainbow chip tray — Layered Paper – rainbow chip tray

I swept half a dozen pictures worth of squares into a small box and gave it away to someone with a larger small-child cross-section than mine, whereupon a slight finger fumble turned the contents into a glitter bomb. Sorry ’bout that.

The Python source code as a GitHub Gist:

	# Generator for rainbow block layered paper
	# Ed Nisley – KE4ZNU
	# 2025-08-03 cargo-culted from svg library examples

	import svg
	import math
	from argparse import ArgumentParser
	from random import randint, choice, seed
	from itertools import chain
	from pprint import pprint

	INCH = 25.4
	X = 0
	Y = 1

	def as_mm(number):
	return repr(number) + "mm"

	parser = ArgumentParser()
	parser.add_argument('–layernum', type=int, default=0)
	parser.add_argument('–colors', type=int, default=16)
	parser.add_argument('–seed', type=int, default=1)
	parser.add_argument('–width', type=int, default=16)
	parser.add_argument('–height', type=int, default=16)
	parser.add_argument('–debug', default=False)
	args = parser.parse_args()

	PageSize = (round(8.5INCH,3), round(11.0INCH,3))

	SheetCenter = (PageSize[X]/2,PageSize[X]/2) # symmetric on Y!

	SheetSize = (200,200) # overall sheet

	AlignOC = (180,180) # alignment pins in corners
	AlignOD = 5.0 # … pin diameter

	MatrixOA = (170,170) # outer limit of cell matrix

	CellCut = "black" # C00 Black
	SheetCut = "red" # C02 Red
	HeavyCut = "rgb(255,128,0)" # C05 Orange black mask paper is harder
	HeavyCellCut = "rgb(0,0,160)" # C09 Dark Blue ditto
	Tooling = "rgb(12,150,217)" # T2 Tool

	DefStroke = "0.2mm"
	DefFill = "none"

	ThisLayer = args.layernum # determines which cells get cut
	Layers = args.colors # black mask = 0, color n = not perforated

	SashWidth = 1.5 # between adjacent cells

	CellSize = ((MatrixOA[X] – (args.width – 1)*SashWidth)/args.width,
	(MatrixOA[Y] – (args.height – 1)*SashWidth)/args.height)
	CellOC = (CellSize[X] + SashWidth,CellSize[Y] + SashWidth)

	if args.seed:
	seed(args.seed)

	#— accumulate tooling layout

	ToolEls = []
	# mark center of sheet for drag-n-drop location
	ToolEls.append(
	svg.Circle(
	cx=SheetCenter[X],
	cy=SheetCenter[Y],
	r="2mm",
	stroke=Tooling,
	stroke_width=DefStroke,
	fill="none",
	)
	)
	# mark page perimeter for alignment check
	if False:
	ToolEls.append(
	svg.Rect(
	x=0,
	y=0,
	width=as_mm(PageSize[X]),
	height=as_mm(PageSize[Y]),
	stroke=Tooling,
	stroke_width=DefStroke,
	fill="none",
	)
	)
	# center huge box on matrix center
	if False:
	ToolEls.append(
	svg.Rect(
	x=as_mm(SheetCenter[X] – 2*SheetSize[X]/2),
	y=as_mm(SheetCenter[Y] – 2*SheetSize[Y]/2),
	width=as_mm(2*SheetSize[X]),
	height=as_mm(2*SheetSize[Y]),
	stroke=Tooling,
	stroke_width=DefStroke,
	fill="none",
	)
	)

	#— accumulate sheet cuts

	SheetEls = []
	# cut perimeter
	SheetEls.append(
	svg.Rect(
	x=as_mm(SheetCenter[X] – SheetSize[X]/2),
	y=as_mm(SheetCenter[Y] – SheetSize[Y]/2),
	width=as_mm(SheetSize[X]),
	height=as_mm(SheetSize[Y]),
	stroke=SheetCut if ThisLayer > 0 else HeavyCut,
	stroke_width=DefStroke,
	fill="none",
	),
	)
	# cut layer ID holes except on mask layer
	if ThisLayer > 0:
	c = ((1,1))
	h = f'{ThisLayer:0{Layers.bit_length()}b}'
	for i in range(Layers.bit_length()):
	SheetEls.append(
	svg.Circle(
	cx=as_mm(SheetCenter[X] + c[X]AlignOC[X]/2 – (i + 2)AlignOD),
	cy=as_mm(SheetCenter[Y] + c[Y]*AlignOC[Y]/2),
	r=AlignOD/4 if h[-(i + 1)] == '1' else AlignOD/8,
	stroke=SheetCut,
	stroke_width=DefStroke,
	fill="none",
	)
	)
	# cut alignment pin holes except on mask layer
	if ThisLayer > 0:
	for c in ((1,1),(-1,1),(-1,-1),(1,-1)):
	SheetEls.append(
	svg.Circle(
	cx=as_mm(SheetCenter[X] + c[X]*AlignOC[X]/2),
	cy=as_mm(SheetCenter[Y] + c[Y]*AlignOC[Y]/2),
	r=as_mm(AlignOD/2),
	stroke=SheetCut,
	stroke_width=DefStroke,
	fill="none",
	)
	)

	#— calculate matrix contents

	CenterPoint = (choice(range(args.width)),choice(range(args.height)))

	CellMatrix = [[math.hypot(x – CenterPoint[X],y – CenterPoint[Y])
	for y in range(args.height)]
	for x in range(args.width)]

	dmax = max(list(chain.from_iterable(CellMatrix)))

	if args.debug:
	print(CenterPoint)
	print(dmax)
	pprint(CellMatrix)
	print()

	#— accumulate matrix cuts

	LayerThreshold = (ThisLayer/Layers)*dmax
	if args.debug:
	print(LayerThreshold)

	MatrixEls = []
	for i in range(args.width):
	x =i*CellOC[X]
	for j in range(args.height):
	y = j*CellOC[Y]

	if args.debug:
	print(i)
	print(j)
	print(CellMatrix[i][j])


	if ThisLayer == 0: # black mask
	s = HeavyCellCut
	elif LayerThreshold < CellMatrix[i][j]: # rest of sheets above color layer
	s = CellCut
	else:
	s = Tooling # at or below color layer

	MatrixEls.append(
	svg.Rect(
	x=as_mm(SheetCenter[X] – MatrixOA[X]/2 + x),
	y=as_mm(SheetCenter[Y] – MatrixOA[Y]/2 + y),
	width=as_mm(CellSize[X]),
	height=as_mm(CellSize[Y]),
	stroke=s,
	stroke_width=DefStroke,
	fill="none",
	)
	)

	#— assemble and blurt out the SVG file

	if not args.debug:
	canvas = svg.SVG(
	width=as_mm(PageSize[X]),
	height=as_mm(PageSize[Y]),
	elements=[
	ToolEls,
	SheetEls,
	MatrixEls
	],
	)

	print(canvas)

view raw Layers – 200mm.py hosted with ❤ by GitHub

2025-08-07

Category: Photography & Images

Walkway Over the Hudson: Camera LEDs

Image Trace and Cut

Cheap HD USB Camera: Base Disassembly

Most Disappointed Squirrel Ever

Hawk With Snake

Mostly Removing Acrylic Scratches

Layered Paper: SVG Generator