Patching ImageFeatures.jl (#25)

Updates ImageFeatures.jl to conform to the new Images. Includes the following changes (with many minor ones also) - 

- Removed all warnings, some failing test cases
- Added grade_matches function
- Minor change in tests of orb.jl
- Fixed lbp.jl and added test cases for it

Author: annimesh2809

.travis.yml

@@ -14,7 +14,7 @@ script:
     - julia -e 'Pkg.add("Images")'  # Needed for Docs 
     - julia -e 'Pkg.clone("https://github.com/JuliaImages/ImageDraw.jl")' # Needed for Docs 
     - julia -e 'Pkg.clone(pwd()); Pkg.build("ImageFeatures")'
-    - julia -e 'Pkg.test("ImageFeatures", coverage=true)'
+    - julia -e 'Pkg.test("ImageFeatures",coverage=true)'
 after_success:
     - if [ $TRAVIS_OS_NAME = "linux" ]; then
          julia -e 'cd(Pkg.dir("ImageFeatures")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())';

docs/src/function_reference.md

@@ -28,7 +28,7 @@ random_uniform
 random_coarse
 gaussian
 gaussian_local
-centered
+center_sample
 ```
 
 ## Feature Extraction

docs/src/tutorials/brief.md

@@ -8,7 +8,7 @@ In ImageFeatures.jl we have five methods to determine the vectors `X` and `Y` :
 - [`gaussian`](@ref) : `X` and `Y` are randomly sampled using a Gaussian distribution, meaning that locations that are closer to the center of the patch are preferred
 - [`gaussian_local`](@ref) : `X` and `Y` are randomly sampled using a Gaussian distribution where first `X` is sampled with a standard deviation of `0.04*S^2` and then the `Yi’s` are sampled using a Gaussian distribution – Each `Yi` is sampled with mean `Xi` and standard deviation of `0.01 * S^2`
 - [`random_coarse`](@ref) : `X` and `Y` are randomly sampled from discrete location of a coarse polar grid
-- [`centered`](@ref) : For each `i`, `Xi` is `(0, 0)` and `Yi` takes all possible values on a coarse polar grid
+- [`center_sample`](@ref) : For each `i`, `Xi` is `(0, 0)` and `Yi` takes all possible values on a coarse polar grid
 
 As with all the binary descriptors, BRIEF’s distance measure is the number of different bits between two binary strings which can also be computed as the sum of the XOR operation between the strings.
 

src/ImageFeatures.jl

@@ -20,6 +20,7 @@ export
 	create_descriptor,
 	hamming_distance,
 	match_keypoints,
+	grade_matches,
 
     #Local Binary Patterns
 	lbp,
@@ -56,5 +57,5 @@ export
 	random_coarse,
 	gaussian,
 	gaussian_local,
-	centered
+	center_sample
 end

src/brief.jl

@@ -127,12 +127,12 @@ end
 
 """
 ```
-sample_one, sample_two = centered(size, window, seed)
+sample_one, sample_two = center_sample(size, window, seed)
 ```
 
 Builds sampling pairs `(Xi, Yi)` where `Xi` is `(0, 0)` and `Yi` is sampled uniformly from the window.
 """
-function centered(size::Int, window::Int, seed::Int)
+function center_sample(size::Int, window::Int, seed::Int)
     srand(seed)
     count = 0
     sample = CartesianIndex{2}[]
@@ -148,7 +148,8 @@ function centered(size::Int, window::Int, seed::Int)
 end
 
 function create_descriptor{T<:Gray}(img::AbstractArray{T, 2}, keypoints::Keypoints, params::BRIEF)
-    img_smoothed = imfilter_gaussian(img, [params.sigma, params.sigma])
+    factkernel = KernelFactors.IIRGaussian([params.sigma, params.sigma])
+    img_smoothed = imfilter(Float64, img, factkernel, NA())
     sample_one, sample_two = params.sampling_type(params.size, params.window, params.seed)
     descriptors = BitArray{1}[]
     h, w = size(img_smoothed)

src/core.jl

@@ -104,4 +104,18 @@ function match_keypoints(keypoints_1::Keypoints, keypoints_2::Keypoints, desc_1,
         end
     end
     matches
-end
+end
+
+"""
+```
+grade = grade_matches(keypoints_1, keypoints_2, limit, difference_method)
+```
+Returns the fraction of keypoint pairs which have
+`difference_method(keypoint_1,keypoint_2)` less than `limit`.
+"""
+
+function grade_matches(keypoints_1::Keypoints, keypoints_2::Keypoints, limit::Real, diff::Function = (i,j) -> (sqrt( (i[1]-j[1])^2 + (i[2]-j[2])^2 )))
+    @assert length(keypoints_1)==length(keypoints_2) "Keypoint lists are of different lengths."
+    @assert length(keypoints_1)!=0 "Keypoint list is of size zero."
+    mean(map((keypoint_1,keypoint_2)->((diff(keypoint_1,keypoint_2) < limit) ? 1.0 : 0.0), keypoints_1, keypoints_2))
+end

src/corner.jl

@@ -18,8 +18,8 @@ function corner_orientations{T<:Gray, K<:Real}(img::AbstractArray{T, 2}, corners
 	pre_y = ceil(Int, (h - 1) / 2)
 	pre_x = ceil(Int, (w - 1) / 2)
 	post_y = floor(Int, (h - 1) / 2)
-	post_x = floor(Int, (w - 1) / 2)
-	img_padded = padarray(img, [pre_y, pre_x], [post_y, post_x], "value", 0)
+       post_x = floor(Int, (w - 1) / 2)
+       img_padded = parent(padarray(img, Fill(0, (pre_y, pre_x), (post_y, post_x))))
 	orientations = Float64[]
 	for c in corners
 		m10 = zero(T)
@@ -49,13 +49,13 @@ end
 function corner_orientations(img::AbstractArray)
     corners = imcorner(img)
     corner_indexes = Keypoints(corners)
-    kernel = gaussian2d(2, [5, 5])
+    kernel = Kernel.gaussian((2,2), (5, 5))
     kernel /= maxfinite(kernel)
-    corner_orientations(img, corner_indexes, kernel)
+    corner_orientations(img, corner_indexes, parent(kernel))
 end
 
 function corner_orientations(img::AbstractArray, corners::Keypoints)
-    kernel = gaussian2d(2, [5, 5])
+    kernel = Kernel.gaussian((2,2), (5, 5))
     kernel /= maxfinite(kernel)
-    corner_orientations(img, corners, kernel)
+    corner_orientations(img, corners, parent(kernel))
 end

src/glcm.jl

@@ -12,12 +12,12 @@ function glcm{T<:Real, A<:Real}(img::AbstractArray{T, 2}, distances::Array{Int,
 end
 
 function glcm{T<:Colorant}(img::AbstractArray{T, 2}, distance::Integer, angle::Real, mat_size::Integer = 16)
-    img_rescaled = map(i -> max(1, Int(ceil((convert(Gray{U8}, i).val.i) * mat_size / 256))), img)
+    img_rescaled = map(i -> max(1, Int(ceil((reinterpret(gray(convert(Gray{N0f8}, i)))) * mat_size / 256))), img)
     _glcm(img_rescaled, distance, angle, mat_size)
 end
 
 function glcm{T<:Colorant, A<:Real}(img::AbstractArray{T, 2}, distances::Array{Int, 1}, angles::Array{A, 1}, mat_size::Integer = 16)
-    img_rescaled = map(i -> max(1, Int(ceil((convert(Gray{U8}, i).val.i) * mat_size / 256))), img)  
+    img_rescaled = map(i -> max(1, Int(ceil((reinterpret(gray(convert(Gray{N0f8}, i)))) * mat_size / 256))), img)  
     glcm_matrices = [_glcm(img_rescaled, d, a, mat_size) for d in distances, a in angles]
     glcm_matrices
 end

src/lbp.jl

@@ -80,7 +80,7 @@ function _direction_coded_lbp{T}(img::AbstractArray{T, 2}, offsets::Array)
 	lbp_image = zeros(UInt, size(img))
 	R = CartesianRange(size(img))
 	p = Int(length(offsets) / 2)
-	raw_img = convert(Array{Int}, raw(img))
+	raw_img = convert(Array{Int}, rawview(channelview(img)))
 	neighbours = zeros(Int, length(offsets))
 	for I in R
 		for (i, o) in enumerate(offsets) neighbours[i] = Int(bilinear_interpolation(img, I[1] + o[1], I[2] + o[2]).val.i) end
@@ -116,16 +116,16 @@ function multi_block_lbp{T<:Gray}(img::AbstractArray{T, 2}, tl_y::Integer, tl_x:
 	lbp_code
 end
 
-function _create_descriptor{T<:FixedPointNumbers.UFixed}(img::AbstractArray{Gray{T}, 2}, yblocks::Integer = 4, xblocks = 4, lbp_type::Function = lbp, args...)
+function _create_descriptor{T<:Normed}(img::AbstractArray{Gray{T}, 2}, yblocks::Integer = 4, xblocks = 4, lbp_type::Function = lbp, args...)
 	h, w = size(img)
     blockh = ceil(Int, h / (yblocks))
     blockw = ceil(Int, w / (xblocks))
     el_max = typemax(FixedPointNumbers.rawtype(eltype(img[1])))
     edges = 0:Int((el_max+1)^0.5):el_max+1
-    descriptor = Int64[]
+    descriptor = Int[]
     for i in 1:xblocks
     	for j in 1:yblocks
-    		lbp_image = lbp_type(img[j : j + blockh - 1, i : i + blockw - 1], args...)
+    		lbp_image = lbp_type(img[(j-1)*blockh+1 : j*blockh, (i-1)*blockw+1 : i*blockw], args...)
     		lbp_norm = lbp_image
     		_, hist = imhist(lbp_image, edges)
     		append!(descriptor, hist[2 : end - 1])
@@ -134,7 +134,7 @@ function _create_descriptor{T<:FixedPointNumbers.UFixed}(img::AbstractArray{Gray
     descriptor
 end
 
-function create_descriptor{T<:FixedPointNumbers.UFixed}(img::AbstractArray{Gray{T}, 2}, yblocks::Integer = 4, xblocks = 4; lbp_type::Function = lbp, args...)
+function create_descriptor{T<:Normed}(img::AbstractArray{Gray{T}, 2}, yblocks::Integer = 4, xblocks = 4; lbp_type::Function = lbp, args...)
     h, w = size(img)
     y_padded = ceil(Int, h / (yblocks)) * yblocks
     x_padded = ceil(Int, w / (xblocks)) * xblocks

test/brief.jl

@@ -1,4 +1,4 @@
-using FactCheck, Images, ImageFeatures, TestImages, Distributions, ColorTypes, TestImages
+using FactCheck, Images, ImageFeatures, TestImages, Distributions
 
 facts("BRIEF") do 
 
@@ -12,7 +12,7 @@ facts("BRIEF") do
     context("Sampling Patterns") do
         # Check Bounds
         for si in [32, 128, 256], wi in [5, 15, 25, 49], se in [123, 546, 178]
-            s1, s2 = centered(si, wi, se)
+            s1, s2 = ImageFeatures.center_sample(si, wi, se)
             @fact check_samples(s1, s2, si, wi) --> true
             @fact s1 == zeros(CartesianIndex{2}, si) --> true
             s1, s2 = random_coarse(si, wi, se)
@@ -27,31 +27,48 @@ facts("BRIEF") do
     end
 
     context("Descriptor Calculation") do
-        img_1 = Gray{Float64}[ 0 0 0 0 0 0 
-                  0 0 1 1 0 0 
-                  0 0 1 1 0 0 
-                  0 0 1 1 0 0 
-                  0 0 1 1 0 0 
-                  0 0 0 0 0 0 ]
+        img_1 = Gray{Float64}[  0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
+                                0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                                0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0  ]
         keypoints_1 = Keypoints(imcorner(img_1))
 
-        img_2 = Gray{Float64}[ 0 0 0 0 0 0  
-                  0 0 1 1 0 0  
-                  0 0 1 1 0 0  
-                  0 0 1 1 0 0  
-                  0 0 1 1 0 0  
-                  0 0 1 1 0 0  
-                  0 0 1 1 0 0  
-                  0 0 0 0 0 0  ]
+        img_2 = Gray{Float64}[ 0 0 0 0 0 0 0 0 0 0
+                               0 0 0 0 0 0 0 0 0 0
+                               0 0 1 1 1 0 0 0 0 0
+                               0 0 1 1 1 1 0 0 0 0
+                               0 0 1 1 1 1 1 0 0 0
+                               0 0 1 1 1 1 1 1 0 0
+                               0 0 1 1 1 1 1 1 0 0
+                               0 0 1 1 1 1 1 1 0 0
+                               0 0 0 0 0 0 0 0 0 0
+                               0 0 0 0 0 0 0 0 0 0 ]
         keypoints_2 = Keypoints(imcorner(img_2))
 
         brief_params = BRIEF(size = 8, window = 3, seed = 123)
 
         desc_1, ret_keypoints_1 = create_descriptor(img_1, keypoints_1, brief_params)
         desc_2, ret_keypoints_2 = create_descriptor(img_2, keypoints_2, brief_params)
         matches = match_keypoints(ret_keypoints_1, ret_keypoints_2, desc_1, desc_2)
-        expected_matches = [[CartesianIndex((2,3)),CartesianIndex((2,3))],
-                            [CartesianIndex((5,3)),CartesianIndex((7,3))]]
+        expected_matches = [[CartesianIndex((5,4)),CartesianIndex((3,3))],
+                            [CartesianIndex((16,4)),CartesianIndex((8,3))],
+                            [CartesianIndex((16,15)),CartesianIndex((8,8))]]
         @fact all(matches .== expected_matches) --> true
 
         img_1 = Gray{Float64}[ 0 0 0 0 0 0 0 0 0