Performance fix for hough_transform_standard (#34)

Author: annimesh2809

src/houghtransform.jl

@@ -1,84 +1,100 @@
 using Images
+
 """
 ```
 lines = hough_transform_standard(image, ρ, θ, threshold, linesMax)
 ```
 
-Returns an vector of tuples corresponding to the tuples of (r,t) where r and t are parameters for normal form of line:
-    x*cos(t) + y*sin(t) = r
+Returns a vector of tuples corresponding to the tuples of (r,t)
+where r and t are parameters for normal form of line:
+    `x \* cos(t) + y \* sin(t) = r`
 
-r = length of perpendicular from (1,1) to the line
-t = angle between perpendicular from (1,1) to the line and x-axis
+-   `r` = length of perpendicular from (1,1) to the line
+-   `t` = angle between perpendicular from (1,1) to the line and x-axis
 
 The lines are generated by applying hough transform on the image.
 
 Parameters:
-    image       = Image to be transformed (eltype should be `Bool`)
-    ρ           = Discrete step size for perpendicular length of line
-    θ           = List of angles for which the transform is computed
-    threshold   = No of points to pass through line for considering it valid
-    linesMax    = Maximum no of lines to return
+-    `image`       = Image to be transformed (eltype should be `Bool`)
+-    `ρ`           = Discrete step size for perpendicular length of line
+-    `θ`           = List of angles for which the transform is computed
+-    `threshold`   = Accumulator threshold for line detection
+-    `linesMax`    = Maximum no of lines to return
+
+# Example
+```julia
+julia> img = load("line.jpg");
+
+julia> img_edges = canny(img, (Percentile(0.99), Percentile(0.97)), 1);
 
+julia> lines = hough_transform_standard(img_edges, 1, linspace(0,π,30), 40, 5)
+5-element Array{Tuple{Float64,Float64},1}:
+ (45.0,1.73329)  
+ (1.0,1.73329)   
+ (32.0,1.73329)  
+ (209.0,0.649985)
+ (-9.0,2.49161) 
+```
 """
 
 function hough_transform_standard{T<:Union{Bool,Gray{Bool}}}(
             img::AbstractArray{T,2},
-            ρ::Number, θ::Range,
+            ρ::Real, θ::Range,
             threshold::Integer, linesMax::Integer)
 
 
     #function to compute local maximum lines with values > threshold and return a vector containing them
-    function findlocalmaxima(accumulator_matrix::Array{Integer,2},threshold::Integer)
-        validLines = Vector{CartesianIndex}(0)
+    function findlocalmaxima!{T<:Integer}(validLines::AbstractVector{CartesianIndex{2}}, accumulator_matrix::Array{Int,2}, threshold::T)
         for val in CartesianRange(size(accumulator_matrix))
-            if  accumulator_matrix[val] > threshold &&
-                accumulator_matrix[val] > accumulator_matrix[val[1],val[2] - 1] &&
+            if  accumulator_matrix[val] >  threshold                             &&
+                accumulator_matrix[val] >  accumulator_matrix[val[1],val[2] - 1] &&
                 accumulator_matrix[val] >= accumulator_matrix[val[1],val[2] + 1] &&
-                accumulator_matrix[val] > accumulator_matrix[val[1] - 1,val[2]] &&
+                accumulator_matrix[val] >  accumulator_matrix[val[1] - 1,val[2]] &&
                 accumulator_matrix[val] >= accumulator_matrix[val[1] + 1,val[2]]
                 push!(validLines,val)
             end
         end
-        validLines
     end
 
     ρ > 0 || error("Discrete step size must be positive")
 
-    height, width = size(img)
+    indsy, indsx = indices(img)
     ρinv = 1 / ρ
     numangle = length(θ)
-    numrho = round(Integer,(2(width + height) + 1)*ρinv)
+    numrho = round(Int,(2(length(indsx) + length(indsy)) + 1)*ρinv)
 
-    accumulator_matrix = zeros(Integer, numangle + 2, numrho + 2)
+    accumulator_matrix = zeros(Int, numangle + 2, numrho + 2)
 
     #Pre-Computed sines and cosines in tables
     sinθ, cosθ = sin.(θ).*ρinv, cos.(θ).*ρinv
 
     #Hough Transform implementation
-    constadd = round(Integer,(numrho -1)/2)
+    constadd = round(Int,(numrho -1)/2)
     for pix in CartesianRange(size(img))
         if img[pix]
             for i in 1:numangle
-                dist = round(Integer, pix[1] * sinθ[i] + pix[2] * cosθ[i])
+                dist = round(Int, pix[1] * sinθ[i] + pix[2] * cosθ[i])
                 dist += constadd
                 accumulator_matrix[i + 1, dist + 1] += 1
             end
         end
     end
 
     #Finding local maximum lines
-    validLines = findlocalmaxima(accumulator_matrix, threshold)
+    validLines = Vector{CartesianIndex{2}}(0)
+    findlocalmaxima!(validLines, accumulator_matrix, threshold)
 
     #Sorting by value in accumulator_matrix
-    sort!(validLines, by = (x)->accumulator_matrix[x], rev = true)
+    @noinline sort_by_votes(validLines, accumulator_matrix) = sort!(validLines, lt = (a,b)-> accumulator_matrix[a]>accumulator_matrix[b])
+    sort_by_votes(validLines, accumulator_matrix)
 
     linesMax = min(linesMax, length(validLines))
 
-    lines = Vector{Tuple{Number,Number}}(0)
+    lines = Vector{Tuple{Float64,Float64}}(0)
 
     #Getting lines with Maximum value in accumulator_matrix && size(lines) < linesMax
     for l in 1:linesMax
-        lrho = ((validLines[l][2]-1) - (numrho - 1)*0.5)*ρ
+        lrho = ((validLines[l][2]-1) - (numrho-1)*0.5)*ρ
         langle = θ[validLines[l][1]-1]
         push!(lines,(lrho,langle))
     end

test/houghtransform.jl

@@ -50,7 +50,7 @@ using ImageFeatures
         end
     end
 
-    img_edges = canny(img, 1, 0.2, 0.1, percentile=false)
+    img_edges = canny(img, (0.2, 0.1) ,1)
     dx, dy=imgradients(img, KernelFactors.ando3)
     img_phase = phase(dx, dy)