Method calcFromVector

source/MRCuda/MRCudaFastWindingNumber.cpp:87–127

}

Expected<void> FastWindingNumber::calcFromVector( std::vector<float>& res, const std::vector<Vector3f>& points, float beta, FaceId skipFace, const ProgressCallback& cb )
{
    MR_TIMER;
    return prepareData_( subprogress( cb, 0.0, 0.5f ) ).and_then( [&]() -> Expected<void>
    {
        const auto totalSize = points.size();
        const auto bufferSize = maxBufferSize( getCudaSafeMemoryLimit(), totalSize, sizeof( float ) + sizeof( float3 ) );

        DynamicArray<float3> cudaPoints;
        CUDA_LOGE_RETURN_UNEXPECTED( cudaPoints.resize( bufferSize ) );
        if ( !reportProgress( cb, 0.6f ) )
            return unexpectedOperationCanceled();

        DynamicArrayF cudaResult;
        CUDA_LOGE_RETURN_UNEXPECTED( cudaResult.resize( bufferSize ) );

        res.resize( points.size() );

        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 );

            CUDA_LOGE_RETURN_UNEXPECTED( cudaPoints.copyFrom( points.data() + offset, size ) );

            fastWindingNumberFromVector( cudaPoints.data(), data_->toData(), cudaResult.data(), beta, int( skipFace ), size );
            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::calcSelfIntersections( FaceBitSet& res, float beta, const ProgressCallback& cb )
{