I have been making good progress with the openMV
the blob function gives you a great bunch of tools.
But I could use some suggestions for finding a horizontal line in my Grayscale/binary Frame.
Major problem: my horizontal line is NOT always PERFECT Horizontal.
So if I make my ROI to narrow, it will miss thin line “horizontal” lines that have a bit of an angle.
I’m mainly using area, elongation and rotation to do some filtering.
But, this is the frame I’m struggling with. Parameter wise this is indeed a horizontal line. But as you see, its just because I have quite some pixels “creating” a elongated box (smallest rectangular box on picture).
Big box is pure my ROI for visualization
Hi, you should use the minimum area rect method returned by find_blobs(). This returns a rectangle that is rotated to match the blob. Also, the minimum area rect has a major axis line and minor axis line which are exactly the values you want. The major axis line will be the longer line.
Oh, really?
I didn’t know it would also do the rotation. Should have read the info more in detail.
Can not wait to give it a try!!!
I think the basics for my project are coming together. Next step is hardware part and I/O programming, but that should be straight forward (I hope)
By the way: the image.write and image.read have helped me tremendously!!! This is a super function to simulate and tweak the software.
if blob.elongation() > 0.5:
img.draw_edges(blob.min_corners(), color=(255,0,0))
img.draw_line(blob.major_axis_line(), color=(0,255,0))
img.draw_line(blob.minor_axis_line(), color=(0,0,255))
The major axis line is what you want. It will return (x0, y0, x1, y1) of a line that goes through the longest axis of the object. It’s based off on the min_corners() method however. So, it’s accuracy depends on that finding the right corners.
Did run some tests with the min_area and indeed a nice function as the axis is indeed rotating (because of the corners).
Will just have to use some Math to calculate the ANGLE of the rotation if I would need this further on.
BUT, probably I didn’t explain my challenge clearly enough, this min_area is not really able to solve the issue.
Objective: detect horizontal lines (some can be slightly tilted)
Problem:
If I make my ROI too narrow(height), the blob function will not find lines (thresholds need to be lowered too much), certainly if they are a bit angled, as to few pixels fall inside the region of interest.
So I need to secure a high enough ROI so that I have enough pixels available to trigger the blob-function.
By making the ROI sufficient High enough, it of course will also detect other “blob-areas”. Most of them I can filter out.
BUT, in some minor cases I have pixels that are connected in a odd shape in a horizontal direction, making the blob trigger.
And at the same time this generates a elongated boundary box that looks extremely similar to a “horizontal line” even when using min_area.
So main issue is, to get a good horizontal line detection without having this false detection.
Currently I am thinking of adding a regression function in my ROI. I expect that the magnitude number of the returned line-object could perhaps give me an indication on how well the pixels are lined up.
But this will probably too sensitive. So still figuring out it I can come up with something else…
As far as I know this is the only way to determine if a triggered blob is just a combination of different shapes or really a long stretched shape of pixels.
In attachment:
Picture of where I get a FALSE line detection. (because in this specific case the pixels are connected in width)
Picture of a detected normal line
Picture of a normal line that requires a high enough ROI, otherwise I wont be able to detect it (without lowering pixel threshold too much and create other noise). This I have covered, just showing example of failed detection if ROI is not high enough
Curious if magnitude could help or if I have to do some other tricks but still securing a robust process
I do not want to include to many crazy filters as it will most likely end up with a system that can only handle perfect images.
Hi, I appreciate your effort to help.
I’m working in a industrial environment with quite some “noise” in the image.
Some lines are not super clear, light conditions vary,…
Meaning if I erode too much, I loose valuable markers. So trying to find good balance to make it robust enough.
I will keep trying and post if I come up with some workarounds.
I need to find a way to get a better grip on the blob result to determine is it’s really a “line” or just some pixels that meet all requirements to theoretical judge it’s a line.
As a Temp solution I adjusted my LAB values to filter out one part of the False-image.
This improves the situation.
Depending on where the robot is I will have to change LAB filter values.
This will get me going for the moment.