Function extractAllSections

source/MRVoxels/MRToolPath.cpp:146–199

computes all sections of modified mesh along the given axis if a selected area is specified in the original mesh, then only points projected on it will be taken into consideration

// computes all sections of modified mesh along the given axis
// if a selected area is specified in the original mesh, then only points projected on it will be taken into consideration
std::vector<PlaneSections> extractAllSections( const Mesh& mesh, const Box3f& box, Axis axis, float sectionStep, int steps, BypassDirection bypassDir, ProgressCallback cb )
{
    auto mainThreadId = std::this_thread::get_id();
    std::atomic<bool> keepGoing{ true };
    std::atomic<size_t> numDone{ 0 };

    std::vector<PlaneSections> sections( steps );

    const int axisIndex = int( axis );
    constexpr Vector3f normals[3] = { {1, 0, 0}, {0, 1, 0}, {0, 0 ,1} };
    const Vector3f normal = normals[axisIndex];
    const auto plane = MR::Plane3f::fromDirAndPt( normal, box.max );

    tbb::parallel_for( tbb::blocked_range<int>( 0, steps ), [&] ( const tbb::blocked_range<int>& range )
    {
        for ( int step = range.begin(); step < range.end(); ++step )
        {
            if ( cb && !keepGoing.load( std::memory_order_relaxed ) )
                break;

            const float currentCoord = plane.d - sectionStep * step;

            auto stepSections = extractPlaneSections( mesh, Plane3f{ plane.n, currentCoord } );

            if ( bypassDir == BypassDirection::Clockwise )
            {
                sections[step] = std::move( stepSections );
                continue;
            }

            sections[step].reserve( stepSections.size() );

            for ( auto& section : stepSections )
            {
                std::reverse( section.begin(), section.end() );
                sections[step].push_back( std::move( section ) );
            }
        }

        if ( cb )
            numDone += range.size();

        if ( cb && std::this_thread::get_id() == mainThreadId )
        {
            if ( !cb( float( numDone ) / float( steps ) ) )
                keepGoing.store( false, std::memory_order_relaxed );
        }
    } );

    if ( !keepGoing.load( std::memory_order_relaxed ) || !reportProgress( cb, 1.0f ) )
        return {};

    return sections;
}

struct ExtractIsolinesResult
{