Method calcFromGridWithDistances

source/MRCuda/MRCudaFastWindingNumber.cpp:230–283

}

Expected<void> FastWindingNumber::calcFromGridWithDistances( std::vector<float>& res, const Vector3i& dims, const AffineXf3f& gridToMeshXf, const DistanceToMeshOptions& options, const ProgressCallback& cb )
{
    MR_TIMER;
    if ( auto maybe = prepareData_( subprogress( cb, 0.0, 0.5f ) ); !maybe )
        return unexpected( std::move( maybe.error() ) );

    const auto getCudaMatrix = [] ( const AffineXf3f& xf )
    {
        Matrix4 res;
        res.x.x = xf.A.x.x; res.x.y = xf.A.x.y; res.x.z = xf.A.x.z;
        res.y.x = xf.A.y.x; res.y.y = xf.A.y.y; res.y.z = xf.A.y.z;
        res.z.x = xf.A.z.x; res.z.y = xf.A.z.y; res.z.z = xf.A.z.z;
        res.b.x = xf.b.x; res.b.y = xf.b.y; res.b.z = xf.b.z;
        res.isIdentity = false;
        return res;
    };
    const Matrix4 cudaGridToMeshXf = ( gridToMeshXf == AffineXf3f{} ) ? Matrix4{} : getCudaMatrix( gridToMeshXf );

    const auto totalSize = (size_t)dims.x * dims.y * dims.z;
    const auto bufferSize = maxBufferSizeAlignedByBlock( getCudaSafeMemoryLimit(), dims, sizeof( float ) );

    DynamicArrayF cudaResult;
    CUDA_LOGE_RETURN_UNEXPECTED( cudaResult.resize( bufferSize ) );
    if ( !reportProgress( cb, 0.6f ) )
        return unexpectedOperationCanceled();

    const auto cb1 = subprogress( cb, 0.60f, 1.00f );
    const auto iterCount = chunkCount( totalSize, bufferSize );
    size_t iterIndex = 0;

    for ( const auto [offset, size] : splitByChunks( totalSize, bufferSize ) )
    {
        const auto cb2 = subprogress( cb1, iterIndex++, iterCount );

        signedDistance(
            int3 { dims.x, dims.y, dims.z },
            cudaGridToMeshXf,
            data_->toData(),
            cudaResult.data(),
            size,
            offset,
            options
        );
        CUDA_LOGE_RETURN_UNEXPECTED( cudaGetLastError() );
        if ( !reportProgress( cb2, 0.25f ) )
            return unexpectedOperationCanceled();

        CUDA_LOGE_RETURN_UNEXPECTED( cudaResult.copyTo( res.data() + offset, size ) );
        if ( !reportProgress( cb2, 1.00f ) )
            return unexpectedOperationCanceled();
    }

    return {};
}

Expected<void> FastWindingNumber::calcFromGridByParts( GridByPartsFunc resFunc, const Vector3i& dims, const AffineXf3f& gridToMeshXf, float beta, int layerOverlap, const ProgressCallback& cb )
{