Method computeFlowsPerBasin

source/MRMesh/MRAggregateFlow.cpp:183–331

}

auto FlowAggregator::computeFlowsPerBasin( size_t numStarts,
    const std::function<MeshTriPoint(size_t)> & startById,
    const std::function<float(size_t)> & amountById ) const -> HashMap<VertId, Flows>
{
    MR_TIMER;

    VertScalars flowInVert( mesh_.topology.vertSize() );
    std::vector<VertId> start2downVert( numStarts ); // for each start point stores what next vertex is on flow path (can be invalid)
    std::vector<VertId> start2rootVert( numStarts );
    std::vector<SurfacePath> start2downPath( numStarts ); // till next vertex

    ParallelFor( start2downVert, [&]( size_t i )
    {
        VertId nextVert;
        if ( auto s = startById( i ); s && !s.isBd( mesh_.topology ) )
        {
            EdgePoint bdPoint;
            start2downPath[i] = computeSteepestDescentPath( mesh_, heights_, s, { .outVertexReached = &nextVert, .outBdReached = &bdPoint } );
            if ( bdPoint )
                start2downPath[i].push_back( bdPoint );
            start2downVert[i] = nextVert;
            if ( nextVert )
                start2rootVert[i] = rootVert_[nextVert];
        }
    } );

    for ( size_t i = 0; i < numStarts; ++i )
    {
        if ( auto v = start2downVert[i] )
            flowInVert[v] += amountById( i );
    }

    for ( size_t i = 0; i < vertsSortedDesc_.size(); ++i )
    {
        auto vUp = vertsSortedDesc_[i];
        if ( !flowInVert[vUp] )
            continue;
        if ( auto vDn = downFlowVert_[vUp] )
            flowInVert[vDn] += flowInVert[vUp];
    }

    HashMap<VertId, std::vector<VertId>> root2firstPolylineVert;

    // paths from sample starts to first mesh vertices
    std::vector<size_t> start2numInRoot;
    start2numInRoot.reserve( numStarts );
    for ( size_t i = 0; i < numStarts; ++i )
    {
        const auto r = start2rootVert[i];
        auto & f = root2firstPolylineVert[r];
        VertId n;
        if ( f.empty() )
            f.push_back( n = 0_v );
        else
            n = f.back();
        start2numInRoot.push_back( f.size() - 1 );
        if ( !start2downPath[i].empty() || start2downVert[i] )
            n += 1 + (int)start2downPath[i].size() + start2downVert[i].valid();