Merge pull request #38 from JuliaImages/fbot/deps

Fix deprecations

Author: timholy

src/brief.jl

@@ -12,7 +12,7 @@ brief_params = BRIEF([size = 128], [window = 9], [sigma = 2 ^ 0.5], [sampling_ty
 | **seed** | Int | Random seed used for generating the sampling pairs. For matching two descriptors, the seed used to build both should be same. |
 
 """
-type BRIEF{F} <: Params
+mutable struct BRIEF{F} <: Params
     size::Int
     window::Int
     sigma::Float64
@@ -147,7 +147,7 @@ function center_sample(size::Int, window::Int, seed::Int)
     zeros(CartesianIndex{2}, size), sample
 end
 
-function create_descriptor{T<:Gray}(img::AbstractArray{T, 2}, keypoints::Keypoints, params::BRIEF)
+function create_descriptor(img::AbstractArray{T, 2}, keypoints::Keypoints, params::BRIEF) where T<:Gray
     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)

src/brisk.jl

@@ -7,7 +7,7 @@ brisk_params = BRISK([pattern_scale = 1.0])
 |----------|------|-------------|
 | `pattern_scale` | `Float64` | Scaling factor for the sampling window |
 """
-type BRISK <: Params
+mutable struct BRISK <: Params
     threshold::Float64
     octaves::Int
     pattern_scale::Float64
@@ -41,8 +41,8 @@ function BRISK(; threshold::Float64 = 0.25, octaves::Int = 4, pattern_scale = 1.
     BRISK(threshold, octaves, pattern_scale, pattern_table, smoothing_table, orientation_weights, short_pairs, long_pairs)
 end
 
-function _brisk_orientation{T<:Gray}(int_img::AbstractArray{T, 2}, keypoint::Keypoint, pattern::Array{SamplePair},
-                                        orientation_weights::Array{OrientationWeights}, sigmas::Array{Float16}, long_pairs::Array{OrientationPair})
+function _brisk_orientation(int_img::AbstractArray{T, 2}, keypoint::Keypoint, pattern::Array{SamplePair},
+                               orientation_weights::Array{OrientationWeights}, sigmas::Array{Float16}, long_pairs::Array{OrientationPair}) where T<:Gray
     direction_sum_y = 0.0
     direction_sum_x = 0.0
     for (i, o) in enumerate(long_pairs)
@@ -79,7 +79,7 @@ function _brisk_tables(pattern_scale::Float64)
     pattern_table, smoothing_table
 end
 
-function create_descriptor{T<:Gray}(img::AbstractArray{T, 2}, features::Features, params::BRISK)
+function create_descriptor(img::AbstractArray{T, 2}, features::Features, params::BRISK) where T<:Gray
     int_img = integral_image(img)
     descriptors = BitArray{1}[]
     ret_features = Feature[]

src/core.jl

@@ -1,4 +1,4 @@
-@compat abstract type Params end
+abstract type Params end
 
 """
 ```
@@ -27,7 +27,7 @@ feature = Feature(keypoint, orientation = 0.0, scale = 0.0)
 
 The `Feature` type has the keypoint, its orientation and its scale.
 """
-immutable Feature
+struct Feature
     keypoint::Keypoint
     orientation::Float64
     scale::Float64

src/corner.jl

@@ -13,7 +13,7 @@ The intensity centroid can be calculated as `C = (m01/m00, m10/m00)` where mpq i
 
 The kernel used for the patch can be given through the `kernel` argument. The default kernel used is a gaussian kernel of size `5x5`.
 """
-function corner_orientations{T<:Gray, K<:Real}(img::AbstractArray{T, 2}, corners::Keypoints, kernel::Array{K, 2})
+function corner_orientations(img::AbstractArray{T, 2}, corners::Keypoints, kernel::Array{K, 2}) where {T<:Gray, K<:Real}
     h, w = size(kernel)
     pre_y = ceil(Int, (h - 1) / 2)
     pre_x = ceil(Int, (w - 1) / 2)
@@ -38,9 +38,9 @@ function corner_orientations{T<:Gray, K<:Real}(img::AbstractArray{T, 2}, corners
     orientations
 end
 
-corner_orientations{T, K<:Real}(img::AbstractArray{T, 2}, corners::Keypoints, kernel::Array{K, 2}) = corner_orientations(convert(Array{Gray}, img), corners, kernel)
+corner_orientations(img::AbstractArray{T, 2}, corners::Keypoints, kernel::Array{K, 2}) where {T, K<:Real} = corner_orientations(convert(Array{Gray}, img), corners, kernel)
 
-function corner_orientations{K<:Real}(img::AbstractArray, kernel::Array{K, 2})
+function corner_orientations(img::AbstractArray, kernel::Array{K, 2}) where K<:Real
     corners = imcorner(img)
     corner_indexes = Keypoints(corners)
     corner_orientations(img, corner_indexes, kernel)

src/freak.jl

@@ -7,7 +7,7 @@ freak_params = FREAK([pattern_scale = 22.0])
 |----------|------|-------------|
 | **pattern_scale** | Float64 | Scaling factor for the sampling window |
 """
-type FREAK <: Params
+mutable struct FREAK <: Params
     pattern_scale::Float64
     pattern_table::Vector{Vector{SamplePair}}
     smoothing_table::Vector{Vector{Float16}}
@@ -28,7 +28,7 @@ function FREAK(; pattern_scale::Float64 = 22.0)
     FREAK(pattern_scale, pattern_table, smoothing_table, orientation_weights)
 end
 
-function _freak_mean_intensity{T<:Gray}(int_img::AbstractArray{T, 2}, keypoint::Keypoint, offset::SamplePair, sigma::Float16)
+function _freak_mean_intensity(int_img::AbstractArray{T, 2}, keypoint::Keypoint, offset::SamplePair, sigma::Float16) where T<:Gray
     y = keypoint[1] + offset[1]
     x = keypoint[2] + offset[2]
     if sigma < 0.5
@@ -42,8 +42,8 @@ function _freak_mean_intensity{T<:Gray}(int_img::AbstractArray{T, 2}, keypoint::
     intensity / ((xst - xs + 1) * (yst - ys + 1))
 end
 
-function _freak_orientation{T<:Gray}(int_img::AbstractArray{T, 2}, keypoint::Keypoint, pattern::Array{SamplePair},
-                                        orientation_weights::Array{OrientationWeights}, sigmas::Array{Float16})
+function _freak_orientation(int_img::AbstractArray{T, 2}, keypoint::Keypoint, pattern::Array{SamplePair},
+                               orientation_weights::Array{OrientationWeights}, sigmas::Array{Float16}) where T<:Gray
     direction_sum_y = 0.0
     direction_sum_x = 0.0
     for (i, o) in enumerate(freak_orientation_sampling_pattern)
@@ -81,7 +81,7 @@ function _freak_tables(pattern_scale::Float64)
     pattern_table, smoothing_table
 end
 
-function create_descriptor{T<:Gray}(img::AbstractArray{T, 2}, keypoints::Keypoints, params::FREAK)
+function create_descriptor(img::AbstractArray{T, 2}, keypoints::Keypoints, params::FREAK) where T<:Gray
     int_img = integral_image(img)
     descriptors = BitArray{1}[]
     ret_keypoints = Keypoint[]

src/glcm.jl

@@ -1,31 +1,31 @@
-function glcm{T<:Real}(img::AbstractArray{T, 2}, distance::Integer, angle::Real, mat_size::Integer = 16)
+function glcm(img::AbstractArray{T, 2}, distance::Integer, angle::Real, mat_size::Integer = 16) where T<:Real
     max_img = maximum(img)
     img_rescaled = map(i -> max(1, Int(ceil(i * mat_size / max_img))), img)
     _glcm(img_rescaled, distance, angle, mat_size)
 end
 
-function glcm{T<:Real, A<:Real}(img::AbstractArray{T, 2}, distances::Array{Int, 1}, angles::Array{A, 1}, mat_size::Integer = 16)
+function glcm(img::AbstractArray{T, 2}, distances::Array{Int, 1}, angles::Array{A, 1}, mat_size::Integer = 16) where {T<:Real, A<:Real}
     max_img = maximum(img)
     img_rescaled = map(i -> max(1, Int(ceil(i * mat_size / max_img))), img)
     glcm_matrices = [_glcm(img_rescaled, d, a, mat_size) for d in distances, a in angles]
     glcm_matrices
 end
 
-function glcm{T<:Colorant}(img::AbstractArray{T, 2}, distance::Integer, angle::Real, mat_size::Integer = 16)
+function glcm(img::AbstractArray{T, 2}, distance::Integer, angle::Real, mat_size::Integer = 16) where T<:Colorant
     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)
+function glcm(img::AbstractArray{T, 2}, distances::Array{Int, 1}, angles::Array{A, 1}, mat_size::Integer = 16) where {T<:Colorant, A<:Real}
     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
 
-glcm{T<:Union{Colorant, Real}, A<:Real}(img::AbstractArray{T, 2}, distances::Int, angles::Array{A, 1}, mat_size::Integer = 16) = glcm(img, [distances], angles, mat_size)
-glcm{T<:Union{Colorant, Real}}(img::AbstractArray{T, 2}, distances::Array{Int, 1}, angles::Real, mat_size::Integer = 16) = glcm(img, distances, [angles], mat_size)
+glcm(img::AbstractArray{T, 2}, distances::Int, angles::Array{A, 1}, mat_size::Integer = 16) where {T<:Union{Colorant, Real}, A<:Real} = glcm(img, [distances], angles, mat_size)
+glcm(img::AbstractArray{T, 2}, distances::Array{Int, 1}, angles::Real, mat_size::Integer = 16) where {T<:Union{Colorant, Real}} = glcm(img, distances, [angles], mat_size)
 
-function _glcm{T}(img::AbstractArray{T, 2}, distance::Integer, angle::Number, mat_size::Integer)
+function _glcm(img::AbstractArray{T, 2}, distance::Integer, angle::Number, mat_size::Integer) where T
     co_oc_matrix = zeros(Int, mat_size, mat_size)
     sin_angle = sin(angle)
     cos_angle = cos(angle)
@@ -70,7 +70,7 @@ function glcm_norm(img::AbstractArray, distances, angles, mat_size)
     co_oc_matrices_norm
 end
 
-function glcm_prop{T<:Real}(gmat::Array{T, 2}, window_height::Integer, window_width::Integer, property::Function)
+function glcm_prop(gmat::Array{T, 2}, window_height::Integer, window_width::Integer, property::Function) where T<:Real
     k_h = Int(floor(window_height / 2))
     k_w = Int(floor(window_width / 2))
     glcm_size = size(gmat)
@@ -82,59 +82,59 @@ function glcm_prop{T<:Real}(gmat::Array{T, 2}, window_height::Integer, window_wi
     prop_mat
 end
 
-glcm_prop{T<:Real}(gmat::Array{T, 2}, window_size::Integer, property::Function) = glcm_prop(gmat, window_size, window_size, property)
+glcm_prop(gmat::Array{T, 2}, window_size::Integer, property::Function) where {T<:Real} = glcm_prop(gmat, window_size, window_size, property)
 
-function glcm_prop{T<:Real}(gmat::Array{T, 2}, property::Function)
+function glcm_prop(gmat::Array{T, 2}, property::Function) where T<:Real
     property(gmat)
 end
 
-function contrast{T<:Real}(glcm_window::Array{T, 2})
+function contrast(glcm_window::Array{T, 2}) where T<:Real
     sum([(id[1] - id[2]) ^ 2 * glcm_window[id] for id in CartesianRange(size(glcm_window))])
 end
 
-function dissimilarity{T<:Real}(glcm_window::Array{T, 2})
+function dissimilarity(glcm_window::Array{T, 2}) where T<:Real
     sum([glcm_window[id] * abs(id[1] - id[2]) for id in CartesianRange(size(glcm_window))])
 end
 
-function glcm_entropy{T<:Real}(glcm_window::Array{T, 2})
+function glcm_entropy(glcm_window::Array{T, 2}) where T<:Real
     -sum(map(i -> i * log(i), glcm_window))
 end
 
-function ASM{T<:Real}(glcm_window::Array{T, 2})
+function ASM(glcm_window::Array{T, 2}) where T<:Real
     sum(map(i -> i ^ 2, glcm_window))
 end
 
-function IDM{T<:Real}(glcm_window::Array{T, 2})
+function IDM(glcm_window::Array{T, 2}) where T<:Real
     sum([glcm_window[id] / (1 + (id[1] - id[2]) ^ 2) for id in CartesianRange(size(glcm_window))])
 end
 
-function glcm_mean_ref{T<:Real}(glcm_window::Array{T, 2})
+function glcm_mean_ref(glcm_window::Array{T, 2}) where T<:Real
     sumref = sum(glcm_window, 2)
     meanref = sum([id * sumref[id] for id = 1:size(glcm_window)[1]])
     meanref
 end
 
-function glcm_mean_neighbour{T<:Real}(glcm_window::Array{T, 2})
+function glcm_mean_neighbour(glcm_window::Array{T, 2}) where T<:Real
     sumneighbour = sum(glcm_window, 1)
     meanneighbour = sum([id * sumneighbour[id] for id = 1:size(glcm_window)[2]])
     meanneighbour
 end
 
-function glcm_var_ref{T<:Real}(glcm_window::Array{T, 2})
+function glcm_var_ref(glcm_window::Array{T, 2}) where T<:Real
     mean_ref = glcm_mean_ref(glcm_window)
     sumref = sum(glcm_window, 2)
     var_ref = sum([((id - mean_ref) ^ 2) * sumref[id] for id = 1:size(glcm_window)[1]])
     var_ref ^ 0.5
 end
 
-function glcm_var_neighbour{T<:Real}(glcm_window::Array{T, 2})
+function glcm_var_neighbour(glcm_window::Array{T, 2}) where T<:Real
     mean_neighbour = glcm_mean_neighbour(glcm_window)
     sumneighbour = sum(glcm_window, 1)
     var_neighbour = sum([((id - mean_neighbour) ^ 2) * sumneighbour[id] for id = 1:size(glcm_window)[2]])
     var_neighbour ^ 0.5
 end
 
-function correlation{T<:Real}(glcm_window::Array{T, 2})
+function correlation(glcm_window::Array{T, 2}) where T<:Real
     mean_ref = glcm_mean_ref(glcm_window)
     var_ref = glcm_var_ref(glcm_window)
     mean_neighbour = glcm_mean_neighbour(glcm_window)
@@ -145,10 +145,10 @@ function correlation{T<:Real}(glcm_window::Array{T, 2})
     sum([glcm_window[i, j] * (i - mean_ref) * (j - mean_neighbour) for i = 1:size(glcm_window)[1], j = 1:size(glcm_window)[2]]) / (var_ref * var_neighbour)
 end
 
-function max_prob{T<:Real}(glcm_window::Array{T, 2})
+function max_prob(glcm_window::Array{T, 2}) where T<:Real
     maxfinite(glcm_window)
 end
 
-function energy{T<:Real}(glcm_window::Array{T, 2})
+function energy(glcm_window::Array{T, 2}) where T<:Real
     ASM(glcm_window) ^ 0.5
 end

src/hog.jl

@@ -12,7 +12,7 @@ Parameters:
 -    block_stride   = stride of blocks. Controls how much adjacent blocks overlap.
 -    norm_method    = block normalization method. Options: L2-norm, L2-hys, L1-norm, L2-sqrt. 
 """
-type HOG <: Params
+mutable struct HOG <: Params
     orientations::Int 
     cell_size::Int
     block_size::Int
@@ -24,7 +24,7 @@ function HOG(; orientations::Int = 9, cell_size::Int = 8, block_size::Int = 2, b
     HOG(orientations, cell_size, block_size, block_stride, norm_method)
 end
 
-function create_descriptor{CT<:Images.NumberLike}(img::AbstractArray{CT, 2}, params::HOG)
+function create_descriptor(img::AbstractArray{CT, 2}, params::HOG) where CT<:Images.NumberLike
     #compute gradient
     gx = imfilter(img, centered([-1 0 1]))
     gy = imfilter(img, centered([-1 0 1]'))
@@ -34,7 +34,7 @@ function create_descriptor{CT<:Images.NumberLike}(img::AbstractArray{CT, 2}, par
     create_hog_descriptor(mag, phase, params)
 end
 
-function create_descriptor{CT<:Images.Color{T, N} where T where N}(img::AbstractArray{CT, 2}, params::HOG)
+function create_descriptor(img::AbstractArray{CT, 2}, params::HOG) where CT<:Images.Color{T, N} where T where N
     #for color images, compute seperate gradient for each color channel and take one with largest norm as pixel's gradient vector
     rows, cols = size(img)
     gx = channelview(imfilter(img, centered([-1 0 1])))
@@ -56,7 +56,7 @@ function create_descriptor{CT<:Images.Color{T, N} where T where N}(img::Abstract
     create_hog_descriptor(max_mag, max_phase, params)
 end
 
-function create_hog_descriptor{T<:Images.NumberLike}(mag::AbstractArray{T, 2}, phase::AbstractArray{T, 2}, params::HOG)
+function create_hog_descriptor(mag::AbstractArray{T, 2}, phase::AbstractArray{T, 2}, params::HOG) where T<:Images.NumberLike
     orientations = params.orientations
     cell_size = params.cell_size
     block_size = params.block_size

src/houghtransform.jl

@@ -37,14 +37,14 @@ julia> lines = hough_transform_standard(img_edges, 1, linspace(0,π,30), 40, 5)
 ```
 """
 
-function hough_transform_standard{T<:Union{Bool,Gray{Bool}}}(
-            img::AbstractArray{T,2},
-            ρ::Real, θ::Range,
-            threshold::Integer, linesMax::Integer)
+function hough_transform_standard(
+img::AbstractArray{T,2},
+ρ::Real, θ::Range,
+threshold::Integer, linesMax::Integer) where T<:Union{Bool,Gray{Bool}}
 
 
     #function to compute local maximum lines with values > threshold and return a vector containing them
-    function findlocalmaxima!{T<:Integer}(validLines::AbstractVector{CartesianIndex{2}}, accumulator_matrix::Array{Int,2}, threshold::T)
+    function findlocalmaxima!(validLines::AbstractVector{CartesianIndex{2}}, accumulator_matrix::Array{Int,2}, threshold::T) where T<:Integer
         for val in CartesianRange(size(accumulator_matrix))
             if  accumulator_matrix[val] >  threshold                             &&
                 accumulator_matrix[val] >  accumulator_matrix[val[1],val[2] - 1] &&
@@ -134,10 +134,10 @@ centers, radii=hough_circle_gradient(img_edges, img_phase, 1, 60, 60, 3:50)
 ```
 """  
 
-function hough_circle_gradient{T<:Number}(
+function hough_circle_gradient(
         img_edges::AbstractArray{Bool,2}, img_phase::AbstractArray{T,2},
         scale::Number, min_dist::Number,
-        vote_thres::Number, radii::AbstractVector{Int})
+        vote_thres::Number, radii::AbstractVector{Int}) where T<:Number
 
     rows,cols=size(img_edges)