When performing visual measurements, there’s one situation that can be particularly frustrating.

The spot has been found.

The outline has also emerged.

The fit doesn't seem to have any major issues.

But when I finally checked the measurement results—well, it just wasn’t stable enough.

At this point, many people’s first reaction is:

Is it possible that the fitting parameters haven't been adjusted properly?

So keep adjusting.

Revise the threshold.

Change the parameters.

The result still floats.

After struggling for a while, I realized that the real problem might not be with the fitting at all.

Instead, among that pile of dots, a few inconspicuous ones had slipped in.Outlier.

Just a few points—does it really have such a big impact?

There really is.

This is also where outliers are most likely to lead people into traps.

Under normal circumstances, most of the contour points, edge points, and measurement points we obtain will be distributed along the true shape of the target.

It looks quite neat.

But as soon as a few obviously off-track points sneak in, things could start to go awry.

If you stare at the screen, you’ll feel:

“Just a few points—how big could it be?”

The problem lies right here.

The human eye sees the whole.

Fitting is about the data.

Those points you think “don’t matter” can still be involved in the calculation.

Finally, a rather awkward situation might arise:

The line has been fitted, but it’s a bit skewed.

The circle is also there, but its position is a bit off.

The borders look pretty much the same, but as soon as you start measuring the dimensions later on, the results start to fluctuate.

The most troublesome thing is that this kind of issue usually doesn't trigger an immediate error.

The software won't pop up a window to tell you:

“Bro, these few points have led you astray.”

It will simply and quietly give you a result.

As for whether this result is usable, you’ll have to judge that for yourself.

Many times, it’s not that we can’t do the fitting—it’s that the data hasn’t been cleaned up properly.

In visual projects, one habit tends to appear particularly often:

Wherever results come out, that’s where you’ll be summoned for a review.

If the fit is unstable, adjust the fit.

If the measurement is inaccurate, adjust the measurement.

If the edges aren't good, keep adjusting the subsequent parameters.

That’s certainly true, but sometimes the direction can go off course.

Because fitting this thing isn't really that mysterious at its core.

What it does is essentially organize a bunch of scattered points into clearer geometric results.

For example, a bunch of points that appear roughly arranged in a straight line.

After fitting, what we obtain is a line that can actually be calculated.

A bunch of points form a circle.

After fitting, we obtain a circle that can continue to be used for calculating position and dimensions.

So, fitting is more like a “tidying-up” process.

It’s not a data-cleaning wizard.

The data itself is messy to begin with—no matter how much you try to fit it later, you can’t magically erase all the problems from thin air.

To put it bluntly:

Fitting isn't about magically transforming dirty data.

It simply organizes relatively reliable data into a more reliable result.

Why do parameters sometimes become more and more chaotic the more you adjust them?

Because the root cause isn't at all in the parameters.

This situation is not uncommon in real-world projects.

At first, I noticed that the fit was a bit off.

So, adjust the parameters.

Tune it a bit better.

Switch to another set of data, and it still doesn't work.

Adjust again.

This round works, but the next round starts drifting again.

In the end, you’ll find yourself falling into a very familiar state:

“Why do I always feel like I’m just a little bit short of the mark?”

This is the time to stop and take a look at what’s ahead.

If the input data constantly contains outliers, the subsequent fitting process will essentially be “working with a disease” all along.

When you adjust the parameters, sometimes you can indeed salvage a bit of the current dataset.

But as soon as the data changes, the problem returns.

So many issues that appear to be “unstable fitting” actually, when traced one step further, turn out to be:

The data itself is unstable.

This is also why, when conducting visual measurements, you can’t just focus solely on the final line or the final circle.

You should take a closer look at:

How exactly did these points come about?

Is there any obvious deviation?

Are there any points that shouldn't have been included in the calculation mixed in?

Sometimes, simply removing those few outlier points can actually be a more direct solution than spending half a day tweaking parameters.

What really matters isn't how many points you can find—it's whether you can actually use them in the end.

Many people who are new to visual measurement tend to pay close attention to “how many points they can find.”

The more dots there are, the more solid it looks.

But what engineers really care about isn't how many tiny dots there are on the screen.

Customers won’t think the project is particularly well done just because you’ve found hundreds of points.

In the end, what everyone cares about is still the outcome.

Can this line be stabilized?

Is the position of this circle accurate?

Can this boundary be used to calculate the dimensions?

If you run the same product multiple times, will the results fluctuate back and forth?

These are the real factors that determine whether a project can actually be implemented.

So from this perspective, fitting is actually a crucial step.

Because the data we obtained earlier was still fragmented.

It’s only at the fitting stage that it truly starts to become “something that can be used in engineering.”

Scattered dots turn into a line.

Scatter points, turning into a circle.

Scattered points turn into boundaries.

Only then can these results proceed to further steps such as dimension measurement, edge detection, and shape analysis.

That is to say:

The point is merely the process; the geometric result is what matters.

Don't just focus on whether it's been fitted.

This is another place that’s easy to overlook.

Some results actually look quite normal when viewed on the screen.

The line is very straight.

The circle is quite round, too.

At first glance, nothing wrong.

But a visual project isn't about who draws more beautifully.

The real question is:

Is it stable?

It's being fitted here today.

Is the next image still here?

If the product undergoes even a slight change, will the results go haywire?

Then, use this result to calculate the dimensions—are the values reliable?

These are far more important than just “the visuals look nice.”

So, when judging whether a fit is good or not, it’s best not to focus solely on the graph.

Take one more look at the original point.

Let’s look at a few more sets of data.

Let’s see if the results are stable.

Especially when the measured values start to fluctuate, don't rush to adjust them backward.

Many times, taking just one step forward can actually make it easier to identify the cause.

Those unassuming little dots are often the ones most worth watching.

There's a rather interesting phenomenon when working on visual projects.

What really causes projects to go through repeated iterations isn't always some particularly complex algorithm.

On the contrary, it could just be a few very small issues.

Several outliers.

A small, unstable edge.

A portion of the data that should not be involved in the fitting.

Taken individually, none of them are exaggerated.

But once these things enter subsequent calculations, they could gradually skew the results.

So when you encounter unstable fitting, don't rush to ask right away:

“Can we adjust another parameter?”

Let me ask first:

“Are these points really reliable?”

Many times, this one sentence is more useful than continuing to tweak a dozen or so parameters.

Fitting the true value means ensuring that the results can be put into practice.

At the end of the day, fitting isn't really a “show-off” feature.

But it's a special project.

Because what visual projects ultimately need isn't just a bunch of isolated dots in the first place.

Rather, it is a result that can be calculated, compared, and reused.

The cleaner the data is upfront, the more reliable the fitted shape will be.

The more stable the fit, the more confident we can be in subsequent measurements.

So, the next time you encounter issues like biased linear fitting, drifting circular fitting, or unstable dimension measurements, first resist the urge to keep tweaking the parameters.

Look back at those points.

What might really skew the results isn't the algorithm or the parameters—it's those few seemingly insignificant outliers.

Sometimes that’s just how visual projects are.

The big problem doesn't necessarily lie in complex places.

Instead, it often hides in those details that “seem like they should be fine.”

And understanding these details thoroughly is often more important than continually making the parameters increasingly complex.