Method addPart

source/MRVoxels/MRMarchingCubes.cpp:432–532

template<typename V>
Expected<void> VolumeMesher::addPart( const V& part )
{
    MR_TIMER;

    const int partFirstZ = nextZ_;
    if ( part.dims.x != indexer_.dims().x || part.dims.y != indexer_.dims().y )
        return unexpected( "XY dimensions of a part must be equal to XY dimensions of whole volume" );
    if ( part.dims.z <= 1 )
        return unexpected( "a part must have at least two Z slices" );
    if ( partFirstZ + part.dims.z > indexer_.dims().z )
        return unexpected( "a part exceeds whole volume in Z dimension" );
    const int layerCount = indexer_.dims().z;

    constexpr bool binary = std::is_same_v<V, SimpleBinaryVolume>;
    if constexpr ( binary )
    {
        int fillFirstZ = partFirstZ;
        if ( fillFirstZ )
            ++fillFirstZ; // skip already filled layer
        ParallelFor( fillFirstZ, fillFirstZ + part.dims.z, [&]( size_t z )
        {
            const auto layerSize = indexer_.sizeXY();
            BitSet layerLowerIso( layerSize );
            const auto firstLayerId = VoxelId( ( z - partFirstZ ) * layerSize );
            for ( size_t i = 0; i < layerSize; ++i )
                layerLowerIso.set( i, !part.data.test( firstLayerId + i ) );
            if ( layerLowerIso.any() )
                lowerIso_[z] = std::move( layerLowerIso );
        } );
    }

    const auto callingThreadId = std::this_thread::get_id();
    std::atomic<bool> keepGoing{ true };

    // avoid false sharing with other local variables
    // by putting processedBits in its own cache line
    constexpr int hardware_destructive_interference_size = 64;
    struct alignas(hardware_destructive_interference_size) S
    {
        std::atomic<int> numProcessedLayers{ 0 };
    } cacheLineStorage;
    static_assert( alignof(S) == hardware_destructive_interference_size );
    static_assert( sizeof(S) == hardware_destructive_interference_size );

    const int firstBlock = partFirstZ / layersPerBlock_;
    nextZ_ = partFirstZ + part.dims.z - 1;
    const bool lastPart = nextZ_ + 1 == indexer_.dims().z;
    const int lastLayer = lastPart ? nextZ_ : nextZ_ - 1;
    assert( lastLayer < layerCount );
    const int lastBlock = lastLayer / layersPerBlock_;

    const auto cb = subprogress( params_.cb, 0.0f, 0.3f );
    auto currentSubprogress = subprogress(
        cb,
        (float)partFirstZ / (float)indexer_.dims().z,
        (float)lastLayer / (float)indexer_.dims().z
    );