Function distanceMapTo2DIsoPolyline

source/MRMesh/MRDistanceMap.cpp:613–887

}

Polyline2 distanceMapTo2DIsoPolyline( const DistanceMap& distMap, float isoValue )
{
    using namespace MarchingSquaresHelper;
    // disambiguate from the same-named types in MRSeparationPoint.h
    using MarchingSquaresHelper::NeighborDir;
    using MarchingSquaresHelper::SeparationPointSet;
    using MarchingSquaresHelper::SeparationPointMap;
    MR_NAMED_TIMER( "distanceMapTo2DIsoPolyline" );
    const size_t resX = distMap.resX();
    const size_t resY = distMap.resY();
    if ( resX == 0 || resY == 0 )
        return {};

    const size_t size = resX * resY;
    auto toId = [resX] ( const Vector2i& pos )->size_t
    {
        return pos.x + pos.y * size_t( resX );
    };

    size_t threadCount = tbb::global_control::active_value( tbb::global_control::max_allowed_parallelism );
    if ( threadCount == 0 )
        threadCount = std::thread::hardware_concurrency();
    if ( threadCount == 0 )
        threadCount = 1;

    const auto blockCount = threadCount;
    const auto blockSize = (size_t)std::ceil( (float)resY / blockCount );
    assert( resY <= blockSize * blockCount );

    std::vector<SeparationPointMap> hmaps( blockCount );
    auto hmap = [&] ( size_t y ) -> SeparationPointMap&
    {
        return hmaps[y / blockSize];
    };

    // find all separate points
    // fill map in parallel
    struct VertsNumeration
    {
        // explicit ctor to fix clang build with `vec.emplace_back( ind, 0 )`
        VertsNumeration( size_t ind, size_t num ) : initIndex{ ind }, numVerts{ num } {}
        size_t initIndex{ 0 };
        size_t numVerts{ 0 };
    };
    using PerThreadVertNumeration = std::vector<VertsNumeration>;
    tbb::enumerable_thread_specific<PerThreadVertNumeration> perThreadVertNumeration;
    tbb::parallel_for( tbb::blocked_range<size_t>( 0, hmaps.size(), 1 ), [&] ( const tbb::blocked_range<size_t>& range )
    {
        assert( range.begin() + 1 == range.end() );
        auto& hmap = hmaps[range.begin()];

        const auto begin = range.begin() * blockSize;
        const auto end = std::min( begin + blockSize, resY );

        auto& localNumeration = perThreadVertNumeration.local();
        localNumeration.emplace_back( begin * resX, 0 );
        auto& thisRangeNumeration = localNumeration.back().numVerts;