find_contours() [1/2]

MAYAFLUX_API std::vector< Contour > MayaFlux::Kinesis::Vision::find_contours	(	const ComponentResult &	components,
		uint32_t	w,
		uint32_t	h,
		float	min_area = 0.0F,
		uint32_t	max_contours = 0,
		uint32_t	max_points_per_contour = 0
	)

Extract contours from an existing CPU component labeling.

Applies the same tracing, filtering, and measurement rules as mask-based extraction without repeating connected-component labeling.

Parameters

components	CPU labeling with a complete w * h label_map and compact foreground labels in 1..count; zero labels are background.
w	Image width in pixels.
h	Image height in pixels.
min_area	Minimum normalised area to retain.
max_contours	Maximum number of contours to return; zero is unlimited.
max_points_per_contour	Maximum trace length; zero is unlimited.

Returns

Outer and hole contours with normalized points and pixel perimeter.

Definition at line 122 of file Contours.cpp.

{
    if (w == 0 || h == 0 || cc.count == 0)
        return {};
 
    const size_t n = static_cast<size_t>(w) * h;
    std::vector<TraceSeed> seeds(cc.count, TraceSeed { .pixel = n, .label = 0, .parent = 0 });
    for (size_t i = 0; i < n; ++i) {
        const uint32_t label = cc.label_map[i];
        if (label != 0 && seeds[label - 1].pixel == n)
            seeds[label - 1] = { .pixel = i, .label = label, .parent = 0 };
    }
 
    std::vector<uint32_t> background(n, 0);
    std::vector<size_t> pending;
    uint32_t region = 0;
    for (size_t seed = 0; seed < n; ++seed) {
        if (cc.label_map[seed] != 0 || background[seed] != 0)
            continue;
 
        ++region;
        pending.clear();
        pending.push_back(seed);
        background[seed] = region;
        bool exterior = false;
        for (size_t head = 0; head < pending.size(); ++head) {
            const size_t pixel = pending[head];
            const auto x = static_cast<uint32_t>(pixel % w);
            const auto y = static_cast<uint32_t>(pixel / w);
            exterior = exterior || x == 0 || y == 0 || x + 1 == w || y + 1 == h;
 
            const auto visit = [&](size_t neighbor) {
                if (cc.label_map[neighbor] == 0 && background[neighbor] == 0) {
                    background[neighbor] = region;
                    pending.push_back(neighbor);
                }
            };
            if (x > 0)
                visit(pixel - 1);
            if (x + 1 < w)
                visit(pixel + 1);
            if (y > 0)
                visit(pixel - w);
            if (y + 1 < h)
                visit(pixel + w);
        }
 
        if (!exterior) {
            const uint32_t parent = cc.label_map[seed - w];
            seeds.push_back({ .pixel = seed, .label = region, .parent = parent });
        }
    }
 
    std::vector<Contour> result(seeds.size());
    std::vector<uint8_t> valid(seeds.size(), 0);
    const size_t max_points = max_points_per_contour > 0
        ? static_cast<size_t>(max_points_per_contour)
        : n * 8;
 
    std::for_each(std::execution::par_unseq,
        std::views::iota(size_t { 0 }, seeds.size()).begin(),
        std::views::iota(size_t { 0 }, seeds.size()).end(),
        [&](size_t ci) {
            const auto& seed = seeds[ci];
            const glm::ivec2 start(static_cast<int32_t>(seed.pixel % w), static_cast<int32_t>(seed.pixel / w));
            const auto inside = [&](glm::ivec2 p) {
                if (p.x < 0 || p.y < 0 || static_cast<uint32_t>(p.x) >= w || static_cast<uint32_t>(p.y) >= h)
                    return false;
                const size_t index = static_cast<size_t>(p.y) * w + static_cast<uint32_t>(p.x);
                return seed.parent == 0 ? cc.label_map[index] == seed.label : background[index] == seed.label;
            };
            const auto points = walk_boundary(start, max_points, inside);
            if (points.size() < 3)
                return;
 
            auto contour = measure_contour(points, w, h, seed.parent);
            if (contour.area < min_area)
                return;
 
            result[ci] = std::move(contour);
            valid[ci] = 1;
        });
 
    std::vector<Contour> out;
    out.reserve(seeds.size());
    for (size_t i = 0; i < seeds.size(); ++i) {
        if (valid[i])
            out.push_back(std::move(result[i]));
    }
 
    if (max_contours > 0) {
        const size_t count = std::min(out.size(), static_cast<size_t>(max_contours));
        std::partial_sort(out.begin(),
            out.begin() + static_cast<ptrdiff_t>(count),
            out.end(),
            [](const Contour& a, const Contour& b) { return a.area > b.area; });
        out.resize(count);
    }
 
    return out;
}

References a, b, count, MayaFlux::Kinesis::Vision::ComponentResult::count, h, index, label, MayaFlux::Kinesis::Vision::ComponentResult::label_map, out, parent, pixel, and points.