Count lines per region automatically with blob analysis

You have a fringe image: six patches of white lines, and you want one count per patch, every cycle, with nobody drawing search lines by hand. The standard pipeline does exactly that in three reusable stages: binarize, find each region with blob analysis, then feed every region's bounding box to an edge counter that reports its own line count. It runs anywhere that offers a particle or blob tool plus an ROI-driven line-profile detector: vision software on a PC at the bench, or the same two tools on a smart camera at the line. This guide walks the whole chain with numbers: pixel budget, lens focal length, light position, the two thresholds that decide success, and the checks that prove the count before you release it.

What you need

Three parts carry this job:

• A camera with manual exposure and manual gain. Any model from the area scan cameras finder works once the pixel budget below is met; a global shutter matters only if the part or the fringes move during exposure.
• Flat, diffuse illumination so the fringes, not the room, set the contrast. One bar light at 30-45° off-axis does it on matte prints.
• Software with two tools: a particle (blob) analysis step that returns a bounding box per particle, and a line-profile or edge-detection step that accepts a region of interest. Every serious vision package and most smart cameras expose both.

For a bench build that grabs one frame per part:

The MV-CU020-90GC is a 2.5 MP GigE camera with a global shutter, a 1/1.7-inch sensor and a C-mount. Its color sensor costs you nothing here: convert to gray before thresholding, or threshold the green channel, where the lens is sharpest.

On the light side:

The LS-BAR-1276 is a diffused white bar, 372 x 28 mm, on 24 V. Set it 150-250 mm from the surface at 30-45° off the camera axis; that placement removes glossy-paper hot spots on most prints, and where it does not, cross-polarization machine vision finishes the job.

The pipeline: find regions first, count second

The order matters. Counting lines first and grouping them by position afterwards breaks the moment the part shifts a few millimetres. Reverse it:

1. Grab one triggered frame with exposure and gain frozen.
2. Threshold to a binary image at the histogram valley.
3. Close the binary image so each region's lines merge into one particle.
4. Run particle analysis; keep one bounding box (top, left, bottom, right) per region.
5. For each particle, set the ROI from its box and count lines with a projected-profile peak count.
6. Emit region index and count: Region 1 = 10 lines, Region 2 = 12, and so on.

The bounding boxes are recomputed every frame, so the regions track the part. That is the whole trick: the ROI is no longer a drawing, it is the output of the blob step. If your regions of interest ever point at the wrong image, read ROI image source binding: fix inspection region errors before touching thresholds; an ROI bound to a stale buffer looks exactly like a threshold failure.

Step 1: One fixed frame

Freeze the acquisition before you touch algorithms. Disable auto exposure and auto gain: an auto loop rebalances between regions of different brightness and drags the threshold with it, the failure mode behind auto exposure and auto gain on color cameras. Trigger one frame per part rather than free-running; the setup steps are in hardware trigger configuration per camera. Shroud the station so the LED is the only light source; then no 100 or 120 Hz mains ripple can modulate the fringes at any exposure.

Step 2: Threshold at the valley

Plot the gray-level histogram of one representative frame. Fringe images are bimodal: a background peak and a line peak. Set the threshold midway between the two peaks, or use the automatic between-class (Otsu) threshold your package offers; both land in the same valley. Never park a threshold on a peak's shoulder: a 10-gray-level move there swings measured line width by whole pixels. The mechanics of choosing that cut are in edge detection without a vision library: threshold basics.

Check the result once against physics. With 0.8 mm lines on a 2.0 mm period, white covers 0.8 / 2.0 = 40 % of a region; a binary image showing 55 % white is eating the gaps, so move the threshold toward the line peak.

Step 3: Close the lines into region blobs

At threshold, each white line is its own particle, dozens per region. Merge them with a morphological closing whose width bridges the widest gap inside a region but never the divider between regions:

At the worked example's scale of 0.03 mm per pixel, a 1.2 mm gap is 40 pixels, so a 60-pixel closing merges the lines; the 7.5 mm divider is 250 pixels and stays open. Filter the particle list by area, keeping particles at least half the median region area, and dust specks vanish. Six particles remain, one per region, found with the same shape-level filtering you would use to detect a circle in a binary image with contour analysis and the same blob-then-decide logic as dark contaminant detection on dark surfaces.

Step 4: Feed each bounding box to the counter

Particle analysis returns, for every particle, its coordinates and extents: a bounding box with four edges, commonly reported as top, left, bottom and right. Convert that box into a rectangle ROI and inset it by 5 % per side; the outermost pixels of a region carry divider shadow and paper edge, and they corrupt the profile.

Inside the ROI, do not run one edge scan along a hand-placed line. Average instead: sum the ROI's columns when the fringes run vertically, and divide by the ROI width. You get a one-dimensional profile whose peaks are the lines. Averaging N pixels cuts random noise by about the square root of N, so 400 rows of averaging is a 20x noise reduction; that is why the projected profile holds up on grainy fringes where a single scan line stutters.

Count peaks, not raw transitions, when the background inside the region is uneven: a peak is a profile point above the midpoint of the profile's own minimum and maximum, separated from the last accepted peak by at least half the smallest fringe period. Each qualifying peak is one white line. If your region starts and ends in a dark gap, edge polarity is cleaner: count rising edges only, one per line. The one-dimensional run-length logic is the same math that counts barcode bars from an image. If you also need the fringe spacing, the same profile gives peak-to-peak distances; how precisely a peak can be located is covered in edge position accuracy from image sampling.

Blob tools return long records: coordinates, area, centroid, angle. Dump one particle and confirm which fields hold the box corners before wiring the loop, the same first move as debugging blob detection output.

Step 5: Verify the count

Prove the pipeline before the line sees it:

1. Hand-count one known sample per region; all six must match.
2. Cross-check with a second method: peak count versus center-line edge count, per region, must agree exactly.
3. Run 100 frames of the same static part; every region's count must be constant to the last digit.
4. Log the geometry: smallest line and smallest gap in pixels. Anything under 3 pixels is a merge waiting to happen.
5. Sum the region counts and compare with a whole-image projection count taken between the dividers; the totals must match.

Check 5 fails loudly when two regions have merged: the blob count drops to five while the line total stays right. That is your alarm for Step 3's closing width.

Worked example: six regions on a 120 mm part

Take a 120 x 90 mm part carrying six fringe regions of 35 x 38 mm separated by 7.5 mm dividers. White lines are 0.8 mm wide on a 2.0 mm period, 0.8 mm line and 1.2 mm gap, so a 35 mm region holds about 35 / 2.0 = 17 lines.

Pixel budget. Four pixels across the narrowest feature is the working minimum; three is where counts start merging. At four pixels per 0.8 mm line, one pixel covers 0.2 mm of object:

120 / 0.2 = 600 pixels across and 90 / 0.2 = 450 down, so 0.27 MP is the floor. Anything from 2 MP up carries three times that with margin, which says plainly: in fringe counting the pipeline is the constraint, not resolution. Size your own part with the calculator:

The LS-CMR-0166 outputs 4000 x 3000 pixels at 30 fps. Over the 120 mm field of view that is 0.03 mm per pixel, so the 0.8 mm lines land 27 pixels wide, the 1.2 mm gaps 40, and a full 2.0 mm period 67, nine times the minimum. The peak counter never sees a marginal fringe at that scale.

Lens. A 1/1.7-inch optical-format sensor is about 7.4 mm wide. Magnification and focal length follow:

m = 7.4 / 120 = 0.062. At a 430 mm working distance, f = 430 x 0.062 / 1.062 = 25.1 mm, so a 25 mm C-mount lens at roughly 430 mm covers the part. The estimate holds within a few percent; focus closes the rest. The lens focal length calculator runs the same two lines with your numbers.

Light and exposure. One diffused white bar at 200 mm and 30-45° off-axis, exposure 5 ms, gain 0 dB, station shrouded. Five milliseconds sits far below the 8.3 ms ripple period of 120 Hz lighting, and with the LED as the only source the exposure length no longer changes the binary image. Run it and the six counts come out 17, 17, 16, 18, 17, 16; the sum, 101, matches the whole-image projection, so check 5 passes.

Choosing camera and light

Three builds cover nearly every fringe job:

• Bench with a PC at the station: the MV-CU020-90GC shown above, 2.5 MP and global shutter on GigE.
• Dense fringes or a bigger part: more pixels per fringe. The MV-CH120-11UC is a 12 MP USB3 camera with the IMX304 sensor and a global shutter, and its 1.1-inch sensor widens the field per lens.

Values as printed in each product's data sheet; open a part for its drawing and full specifications.

• No PC at the line: run the same two tools on-device.

The MV-SC3050XC-16M-ATN-H is a 5 MP vision sensor on Fast Ethernet with a global shutter; blob plus line-profile steps ship in that class of toolchain, and the counts ride out on Ethernet I/O.

On motion: the rolling-shutter LS-CMR-0166 suits this bench set-up, where the part is still during exposure. Put the part on a moving conveyor and a rolling shutter skews the lines, so there you want one of the global-shutter builds above.

When the count goes wrong

Four failure modes account for nearly every wrong number:

• Two regions merge. Five particles instead of six, one box spanning two patches. Cause: a closing wider than the divider, or divider contrast below threshold. Fix: keep the divider at least 4x the widest intra-region gap, 7.5 mm against 1.2 mm here, and re-check the closing width.
• Counts collapse to half. A region that hand-counts 17 reports 9. Cause: gaps under 3 pixels, so two lines fuse into one peak. Fix: shorten the working distance or step up sensor pixels; halving the pixel size on object doubles the pixels per gap.
• The count flickers between frames. Cause: auto exposure or gain riding along, or a threshold on a histogram shoulder. Fix: freeze both, move the threshold to the valley, add 10 gray levels of hysteresis.
• A glare streak reads as a line. On glossy prints a specular streak is a bright ridge exactly like a fringe. Fix: diffuse light off-axis, then cross-polarize if highlights remain.

Checklist before you build

• Pixel budget: smallest line and gap at 4 pixels or more, sized with the calculator above.
• Lens: f from m = sensor width / FOV at your working distance; 25 mm C-mount covers a 120 mm FOV near 430 mm.
• Light: one diffuse bar at 30-45°, shrouded station, exposure and gain frozen, one frame per part on trigger.
• Threshold: valley midpoint, 10 gray levels of hysteresis.
• Closing: 1.5x the widest intra-region gap, divider 4x that gap.
• Counter: profile midpoint peak rule, separation half the smallest period, ROI inset 5 %.
• Proof: hand-count match, cross-method match, 100-frame stability, geometry logged, sum check equal to the whole-image projection.

Run your part's numbers first in the system configurator, or bring the fringe image to us through the contact page and we will size the chain with you.