Skip to content

Avoid queue duplicates in morphological reconstruction backward scan #232

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
wkearn merged 2 commits into from
Jul 31, 2026
Merged

Avoid queue duplicates in morphological reconstruction backward scan #232

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
7c902a5
Avoid queue duplicates
hawahee Jul 30, 2026
68dda81
Remove backward scan from repeat check
hawahee Jul 30, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 7 additions & 17 deletions src/reconstruct.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -187,12 +187,8 @@ ptrdiff_t backward_scan(float *marker, PixelQueue *queue, float *mask,
}

if (marker[q] < marker[p] && marker[q] < mask[q]) {
if (enqueue(queue, p) == 0) {
// In hybrid mode, we don't need to count the changes:
// Instead, we use the return value to signal if we need
// to repeat the scan because the queue filled up.
return -1;
};
enqueue(queue, p);
break;
}
}
}
Expand Down Expand Up @@ -283,10 +279,9 @@ void reconstruct(float *marker, float *mask, ptrdiff_t dims[2]) {

Requires a ptrdiff_t array of the same size as the marker and mask
arrays for use as the backing store of a PixelQueue. The PixelQueue
can only store dims[0]*dims[1] - 1 pixels. In the unlikely event
that it fills up, either during the `backward_scan` step or the
`propagate` step, the `repeat` flag is set, and the process is
repeated to ensure that the algorithm converges.
can only store dims[0]*dims[1] - 1 pixels. In the unlikely event that
it fills up during the `propagate` step, the `repeat` flag is set,
and the process is repeated to ensure that the algorithm converges.
*/
int reconstruct_hybrid(float *marker, ptrdiff_t *queue, float *mask,
ptrdiff_t dims[2]) {
Expand All @@ -299,13 +294,8 @@ int reconstruct_hybrid(float *marker, ptrdiff_t *queue, float *mask,
int32_t repeat = 0;
do {
forward_scan(marker, mask, dims);

repeat = 0;
// Backward scan returns -1 if the queue fills up, in which case
// we need to repeat the scan.
repeat |= (backward_scan(marker, &q, mask, dims) == -1);
repeat |= propagate(marker, &q, mask, dims);

backward_scan(marker, &q, mask, dims);
repeat = propagate(marker, &q, mask, dims);
scans++;
} while (repeat && scans < max_scans);
return (scans == max_scans) && repeat;
Expand Down
Loading