Building My Own Tool Scanner — Part 5: Okay, I've Scanned It. Now What?

At this stage, the scanner was finally doing what I'd originally wanted from the hardware.

Put a tool down.

Capture it.

Generate a usable representation of its shape.

Great.

But there was still a rather large gap between:

“I've scanned a tool.”

and:

“There's a Gridfinity insert sitting on my printer.”

The scanner had solved the measurement problem.

It hadn't solved the workflow.

The first web builder

My first attempt at bridging that gap was a relatively simple web-based builder.

The idea was to give myself an interface where I could work with the scanned tool profiles without having to manually recreate everything from scratch in CAD.

Nothing particularly ambitious.

Just take some of the repetitive work out of the process.

And it worked.

Which is usually where my projects become considerably more complicated. 😂

If it can do that...

Once the basic builder was working, the obvious thought was:

Could it do this as well?

Then another feature gets added.

Then another.

Each iteration removed another small piece of the manual workflow.

The scanner itself was improving at the same time, so the quality of the data going into the builder was getting better too.

Gradually, more of the process moved away from manually recreating geometry in CAD.

But I was beginning to run into another problem.

I was simplifying the wrong workflow

The web builder was making the existing process easier.

But I was still fundamentally taking a scanned profile and then doing a collection of operations required to turn it into a Gridfinity insert.

Position the tool.

Create the base.

Create the pocket.

Set the depth.

Work out finger access.

Keep everything inside the boundaries.

Deal with inserts larger than the printer's build area.

Repeat for additional tools.

It was certainly better than measuring every tool manually.

But I was still spending too much time managing the process.

I hadn't really solved it.

I'd just made it less annoying.

That distinction became increasingly obvious as I scanned more tools.

Build around the actual job

Eventually I stopped thinking about it as a generic builder.

The job wasn't:

Manipulate some scanned geometry.

The job was:

Make Gridfinity tool inserts.

Once I looked at it that way, the software needed to understand the workflow rather than simply provide tools for me to perform it manually.

So instead of continually extending the original web builder, I started building something specifically around the task.

A dedicated Gridfinity Generator.

What does the generator actually need to know?

There are some things the scanner can determine very well.

The tool's 2D profile.

Its physical X/Y dimensions.

Its position within the scanned image.

But there are other things a camera looking straight down simply cannot know.

For example:

How deep should the tool sit?

That's a design decision.

Likewise, I might want additional finger clearance around part of the tool so it's easy to remove.

I might want several tools inside one insert.

The resulting tray might be larger than my printer can physically print in one piece.

Those are jobs for the generator.

So the two parts of the system started developing very distinct responsibilities.

Scanner: tell me what shape the tool is.

Generator: tell me how that shape should become a Gridfinity insert.

The workflow starts coming together

The generator could now take care of the repetitive parts of building the insert.

Define the Gridfinity base.

Add and position tool profiles.

Assign pocket depths.

Add finger access.

Maintain safe boundaries.

Handle multiple tools.

Split larger designs into printable sections where necessary.

The goal wasn't to remove every engineering decision.

Quite the opposite.

I wanted the software to remove the boring repeatable operations so that I only had to make the decisions that actually mattered.

That was considerably closer to what I'd imagined at the beginning of the project.

But there was still one rather important problem sitting between the scanner and the generator.

The scanner produced a mask.

The generator ultimately needed geometry.

And my first attempts at bridging those two worlds became more complicated than I wanted.

There had to be a simpler way.

Again.

Next: Part 6 — Stop Reinventing the Vector

I'd already solved camera calibration.

I'd solved illumination.

I'd built the scanner.

I'd built the Gridfinity Generator.

And then I realised I was spending time trying to solve another problem for which mature software already existed.

Sometimes the clever solution is knowing when not to write more code.