Distance between contours in Julia - julia

Question

Hi I'm using contour detection in Julia to detect contours. UPDATE: I need to find closest distance between two contours (made from broken lines).Is there function that finds the closest distance ? I'm not sure whats the best way of joining those two.
The case I'm looking at is
so I've used the code given at link example link
[https://juliaimages.org/v0.21/democards/examples/contours/contour_detection/] I've contours with n-element Vector{CartesianIndex} datatype. How do I join the line / two contours?
UPDATE: I've tried removing close contour points using the following
sorted_contours = sort!(contours, by=x -> x[1])
for i in eachindex(sorted_contours)
if check_adjacent(sorted_contours[i], sorted_contours) >= 1
sorted_contours[i] = CartesianIndex.(0, 0)
end
end
deleteat!(sorted_contours,findall(sorted_contours.==CartesianIndex.(0, 0))) but from this [![enter image description here][3]][3] it improved to this only [![enter image description here][3]][3]
I want to remove these points as these are incorrect contour points. Or how could I remove the spur which causes it?

Answer 1

You are vague in your question (as of 27 November) about the packages you are using. If you are using Contour, here is a nonoptimized way to find the minimum distance between two contours. You would need to select the two contours using contour() for the different x, y, z sets of values in each of your different contours.
using Contour
using Distances
const x = -3:0.01:3
const y = -4:0.02:5
const z = [Float64((xi^2 + yi^2)) for xi in x, yi in y]
x5, y5 = contour(x, y, z, 5) |> lines |> first |> coordinates
points5 = [[x5[i], y5[i]] for i in eachindex(x5)]
x10, y10 = contour(x, y, z, 10) |> lines |> first |> coordinates
points10 = [[x10[i], y10[i]] for i in eachindex(x10)]
distances = [(euclidean(p1, p2), p1, p2) for p1 in points5, p2 in points10]
d, idx = findmin(t -> t[1], distances)
#show d, idx #(d, idx) = (0.9261944913478685, CartesianIndex(918, 126))
#show distances[idx] # distances[idx] = (0.9261944913478685, [1.64, 1.52], [2.32, 2.1488372093023256])
#show points5[idx[1]] points10[idx[2]]
# points5[idx[1]] = [1.64, 1.52]
# points10[idx[2]] = [2.32, 2.1488372093023256]

Answer 2

It's the best approach to show your effort and explain where you have the problem, and you'll get the best answers to solve it. Since this topic interested me and made me curious, I found it worthwhile, although your question doesn't meet the requirements of a good question.
To better detect the contours, First, I perform thinning on the image to locate the contours easily. I use the following image as the input to see the results in a bigger size:
using Images, FileIO, ImageBinarization
img = load("img.png")
gimg = Gray.(img)
bin = binarize(gimg, UnimodalRosin()) .> 0.5
thinned = thinning(bin, algo=GuoAlgo())
The thinned variable represents the following picture:
julia> Gray.(thinned)
Now, I define my functions to find the contours:
"""
check_adjacent(loc::CartesianIndex{2}, all_locs::Vector{CartesianIndex{2}})
Return the number of adjacent locations that are in `all_locs` to `loc`.
This function is used to determine whether a location is a corner (contour) or not.
# Arguments
- `loc::CartesianIndex{2}`: the location to check.
- `all_locs::Vector{CartesianIndex{2}}`: all the locations that aren't black.
# Returns
- `Int`: the number of adjacent locations that are in `all_locs` to `loc`.
"""
function check_adjacent(loc::CartesianIndex{2}, all_locs::Vector{CartesianIndex{2}})
conditions = [
loc - CartesianIndex(0,1) ∈ all_locs,
loc + CartesianIndex(0,1) ∈ all_locs,
loc - CartesianIndex(1,0) ∈ all_locs,
loc + CartesianIndex(1,0) ∈ all_locs,
loc - CartesianIndex(1,1) ∈ all_locs,
loc + CartesianIndex(1,1) ∈ all_locs,
loc - CartesianIndex(1,-1) ∈ all_locs,
loc + CartesianIndex(1,-1) ∈ all_locs
]
return sum(conditions)
end
"""
find_the_contour(img::BitMatrix)
Return the contours of the image `img`.
# Arguments
- `img::BitMatrix`: the image to get the contours of.
# Returns
- `Vector{CartesianIndex{2}}`: the contours of the image `img`.
"""
function find_the_contour(img::BitMatrix)
img_matrix = convert(Array{Float64}, img)
not_black = findall(!=(0.0), img_matrix)
contours = Vector{CartesianIndex{2}}()
for nb∈not_black
t = check_adjacent(nb, not_black)
t==1 && push!(contours, nb)
end
return contours
end
Now I use the find_the_contour function:
julia> contours = find_the_contour(thinned)
4-element Vector{CartesianIndex{2}}:
CartesianIndex(161, 334)
CartesianIndex(256, 452)
CartesianIndex(69, 1213)
CartesianIndex(210, 1243)
How should I know this function locates the contours correctly? I define another function to highlight the contours:
"""
highlight_contours(img, contours)
Return the image `img` with the contours `contours` highlighted with red color.
# Arguments
- `img::BitMatrix`: the image to highlight the contours on.
- `contours::Vector{CartesianIndex{2}}`: the contours to highlight.
- `resize`::Bool=false: whether to resize the image to 512x512 or not.
- `scale`::Union{Int64, Float64}=1: the scale to resize the image to.
# Returns
- `img_matrix`: the image `img` with the contours `contours` highlighted with red color.
"""
function highlight_contours(img, contours; resize::Bool=false, scale::Union{Int64, Float64}=1)
img_matrix = convert(Array{RGB, 2}, img)
for c∈contours
img_matrix[c] = RGB(1,0,0)
end
if resize
img_matrix = typeof(scale)==Int64 ? imresize(img_matrix, size(img).*scale) : imresize(img_matrix, ratio=scale)
end
return img_matrix
end
Then I pass the thinned Matrix and contours to it:
julia> highlited = highlight_contours(thinned, contours)
If you zoom in a little bit, you find the contours with red color:
Now that I made sure the contours are located successfully, I go for calculating the distance between contours. I used the Euclidean distance between the CartesianIndexes of each contour! You can adjust it to match your taste:
"""
distance_between_contours(V::Vector{T}, v::T) where T<:Tuple{Int64, Int64}
Return the euclidean distance between the contour `v` and the contours in `V`.
# Arguments
- `V::Vector{T}`: the contours to check the distance to.
- `v::T`: the contour to check the distance from.
# Returns
- `Float64`: the euclidean distance between the contour `v` and the contours in `V`.
"""
function distance_between_contours(V::Vector{T}, v::T) where T<:Tuple{Int64, Int64}
return broadcast((x, y)->sqrt(sum((x.-y).^2)), V, Ref(v))
end
"""
distance_between_contours(all_contours::Vector{CartesianIndex{2}})
Return the euclidean distance between each pair of contours in `all_contours`.
# Arguments
- `all_contours::Vector{CartesianIndex{2}}`: the contours to calculate the distance between.
# Returns
- `Matrix{Float64}`: the euclidean distance between each pair of contours in `all_contours`.
"""
function distance_between_contours(all_contours::Vector{CartesianIndex{2}})
n = length(all_contours)
distances = Matrix{Float64}(undef, n, n)
for j in eachindex(all_contours)
distances[:, j] .= distance_between_contours(
Tuple.(all_contours),
Tuple(all_contours[j])
)
end
return distances
end
Now I pass it the contours and calculate the pairwise Euclidean distance between each:
julia> distance_between_contours(contours)
4×4 Matrix{Float64}:
0.0 151.489 883.801 910.32
151.489 0.0 783.639 792.336
883.801 783.639 0.0 144.156
910.32 792.336 144.156 0.0
In this matrix, for example, the 151.489 value shows the distance between the first contour and the second. Remember that the first and second contours are the followings:
CartesianIndex(161, 334)
CartesianIndex(256, 452)
I followed the same procedure for your image, and this the followings are the distances and the contours:
julia> distance_between_contours(contours)
6×6 Matrix{Float64}:
0.0 27.7308 88.6397 168.6 166.676 170.188
27.7308 0.0 60.9262 140.872 139.284 142.622
88.6397 60.9262 0.0 80.1311 79.2465 82.0061
168.6 140.872 80.1311 0.0 26.2488 19.2354
166.676 139.284 79.2465 26.2488 0.0 8.06226
170.188 142.622 82.0061 19.2354 8.06226 0.0
highlited = highlight_contours(thinned, contours, resize=true, scale=2)
TL;DR
Code:
using Images, FileIO, ImageBinarization
function check_adjacent(loc::CartesianIndex{2}, all_locs::Vector{CartesianIndex{2}})
conditions = [
loc - CartesianIndex(0,1) ∈ all_locs,
loc + CartesianIndex(0,1) ∈ all_locs,
loc - CartesianIndex(1,0) ∈ all_locs,
loc + CartesianIndex(1,0) ∈ all_locs,
loc - CartesianIndex(1,1) ∈ all_locs,
loc + CartesianIndex(1,1) ∈ all_locs,
loc - CartesianIndex(1,-1) ∈ all_locs,
loc + CartesianIndex(1,-1) ∈ all_locs
]
return sum(conditions)
end
function find_the_contour(img::BitMatrix)
img_matrix = convert(Array{Float64}, img)
not_black = findall(!=(0.0), img_matrix)
contours = Vector{CartesianIndex{2}}()
for nb∈not_black
t = check_adjacent(nb, not_black)
t==1 && push!(contours, nb)
end
return contours
end
function distance_between_contours(V::Vector{T}, v::T) where T<:Tuple{Int64, Int64}
return broadcast((x, y)->sqrt(sum((x.-y).^2)), V, Ref(v))
end
function distance_between_contours(all_contours::Vector{CartesianIndex{2}})
n = length(all_contours)
distances = Matrix{Float64}(undef, n, n)
for j in eachindex(all_contours)
distances[:, j] .= distance_between_contours(
Tuple.(all_contours),
Tuple(all_contours[j])
)
end
return distances
end
img = load("img.png")
gimg = Gray.(img)
bin = binarize(gimg, UnimodalRosin()) .> 0.5
thinned = thinning(bin, algo=GuoAlgo())
contours = find_the_contour(thinned)
distance_between_contours(contours)