boolean_indicator

boolean_indicator(f::AbstractArray)
boolean_indicator(f::AbstractGPUArray)
boolean_indicator(f::BitArray)

Create a float representation of a boolean indicator array where 0 represents the background and 1 represents the foreground. This function converts a logical array into a floating-point array where foreground values (logical 1) are marked as 0.0f0 (float representation of 0), and background values (logical 0) are marked with a large float number 1.0f10. This representation is useful in distance transform operations to differentiate between the foreground and the background.

Arguments

• f: An array of boolean values or an AbstractGPUArray of boolean values, where true indicates the foreground and false indicates the background.

Returns

• A floating-point array of the same dimensions as f, with foreground values set to 0.0f0 and background values set to 1.0f10.

Performance

• If f is a BitArray, the conversion uses LoopVectorization.jl for a potential speedup. The warning check arguments are disabled for performance reasons.
• If f is an AbstractGPUArray, the computation is offloaded to the GPU using a custom kernel, boolean_indicator_kernel, which is expected to yield a significant speedup on compatible hardware.

Examples

f = BitArray([true, false, true, false])
f_float = boolean_indicator(f)
# f_float will be Float32[0.0f0, 1.0f10, 0.0f0, 1.0f10]

f_gpu = CUDA.zeros(Bool, 10) # assuming CUDA.jl is used for GPU arrays
f_gpu[5] = true
f_float_gpu = boolean_indicator(f_gpu)
# f_float_gpu will be a GPU array with the fifth element as 0.0f0 and others as 1.0f10

Notes

• The choice of 1.0f10 as the large number is arbitrary and can be adjusted if needed for specific applications.
• The @turbo macro from LoopVectorization.jl is used when f is a BitArray to unroll and vectorize the loop for optimal performance.
• When f is an AbstractGPUArray, the boolean_indicator_kernel kernel function is used to perform the operation in parallel on the GPU.
• The KernelAbstractions.synchronize(backend) call ensures that all GPU operations are completed before returning the result.

transform!

transform!(f::AbstractVector, output, v, z)
transform!(img::AbstractMatrix, output, v, z; threaded=true)
transform!(vol::AbstractArray{<:Real,3}, output, v, z, temp; threaded=true)
transform!(img::AbstractGPUMatrix, output, v, z)

In-place squared Euclidean distance transforms. These functions apply the transform to the input data and store the result in the output argument.

• The first function operates on vectors.
• The second function operates on matrices with optional threading.
• The third function operates on 3D arrays with optional threading.
• The fourth function is specialized for GPU matrices.

The intermediate arrays v and z (and temp for 3D arrays) are used for computation. The threaded parameter enables parallel computation on the CPU.

Arguments

• f: Input vector, matrix, or 3D array.
• output: Preallocated array to store the result.
• v: Preallocated array for indices, matching the dimensions of f.
• z: Preallocated array for intermediate values, one element larger than f.
• temp: Preallocated array for intermediate values when transforming 3D arrays, matching the dimensions of output.

Examples

f = rand([0f0, 1f0], 10)
f_bool = boolean_indicator(f)
output = similar(f)
v = ones(Int32, size(f))
z = ones(eltype(f), size(f) .+ 1)
transform!(f_bool, output, v, z)

transform

transform(f::AbstractVector)
transform(img::AbstractMatrix; threaded=true)
transform(vol::AbstractArray{<:Real,3}; threaded=true)
transform(img::AbstractGPUMatrix)

Non-in-place squared Euclidean distance transforms that return a new array with the result. They allocate necessary intermediate arrays internally.

• The first function operates on vectors.
• The second function operates on matrices with optional threading.
• The third function operates on 3D arrays with optional threading.
• The fourth function is specialized for GPU matrices.

The threaded parameter can be used to enable or disable parallel computation on the CPU.

Arguments

• f/img/vol: Input vector, matrix, or 3D array to be transformed.

Examples

f = rand([0f0, 1f0], 10)
f_bool = boolean_indicator(f)
f_tfm = transform(f_bool)