Added Histogram of Gradient Features (#37)

Author: tejus-gupta

.travis.yml

@@ -4,7 +4,7 @@ os:
     - osx
 julia:
     - nightly
-    - 0.5
+    - 0.6
 notifications:
     email: false
 script:

appveyor.yml

@@ -1,7 +1,7 @@
 environment:
   matrix:
-  - JULIAVERSION: "julialang/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-  - JULIAVERSION: "julialang/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
+  - JULIAVERSION: "julialang/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
   - JULIAVERSION: "julianightlies/bin/winnt/x86/julia-latest-win32.exe"
   - JULIAVERSION: "julianightlies/bin/winnt/x64/julia-latest-win64.exe"
 

src/ImageFeatures.jl

@@ -16,8 +16,9 @@ include("orb.jl")
 include("freak.jl")
 include("brisk.jl")
 include("houghtransform.jl")
+include("hog.jl")
 
-export Keypoint, Keypoints, Feature, Features, Params, BRIEF, ORB, FREAK, BRISK
+export Keypoint, Keypoints, Feature, Features, Params, BRIEF, ORB, FREAK, BRISK, HOG
 
 export
     #Core

src/hog.jl

@@ -0,0 +1,188 @@
+"""
+```
+hog_params = HOG([orientations = 9], [cell_size = 8], [block_size = 2], [block_stride = 1], [norm_method = "L2-norm"])
+```
+
+Histogram of Oriented Gradient (HOG) is a dense feature desciptor usually used for object detection. See "Histograms of Oriented Gradients for Human Detection" by Dalal and Triggs.
+
+Parameters:  
+-    orientations   = number of orientation bins
+-    cell_size      = size of a cell is cell_size x cell_size (in pixels)
+-    block_size     = size of a block is block_size x block_size (in terms of cells)
+-    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
+    orientations::Int 
+    cell_size::Int
+    block_size::Int
+    block_stride::Int 
+    norm_method::String
+end
+
+function HOG(; orientations::Int = 9, cell_size::Int = 8, block_size::Int = 2, block_stride::Int = 1, norm_method::String = "L2-norm")
+    HOG(orientations, cell_size, block_size, block_stride, norm_method)
+end
+
+function create_descriptor{CT<:Images.NumberLike}(img::AbstractArray{CT, 2}, params::HOG)
+    #compute gradient
+    gx = imfilter(img, centered([-1 0 1]))
+    gy = imfilter(img, centered([-1 0 1]'))
+    mag = hypot.(gx, gy)
+    phase = orientation.(gx, gy)
+
+    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)
+    #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])))
+    gy = channelview(imfilter(img, centered([-1 0 1]')))
+    mag = hypot.(gx, gy)
+    phase = orientation.(gx, gy)
+
+    max_mag = zeros(rows, cols)
+    max_phase = zeros(rows, cols)
+
+    for j in indices(mag, 3)
+        for i in indices(mag, 2)
+            ind = indmax(mag[:, i, j])
+            max_mag[i, j] = mag[ind, i, j]
+            max_phase[i, j] = phase[ind, i, j]
+        end
+    end
+
+    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)
+    orientations = params.orientations
+    cell_size = params.cell_size
+    block_size = params.block_size
+    block_stride = params.block_stride
+
+    rows, cols = size(mag)
+    if rows%cell_size!=0 || cols%cell_size!=0
+        error("Height and Width of the image must be a multiple of cell_size.")
+    end
+
+    cell_rows::Int = rows/cell_size
+    cell_cols::Int = cols/cell_size
+    if (cell_rows-block_size)%block_stride!=0 || (cell_cols-block_size)%block_stride!=0
+        error("Block size and block stride don't match.")
+    end
+
+    phase = abs.(phase*180/pi)
+
+    #orientation binning for each cell
+    hist = zeros(Float64, (orientations, cell_rows, cell_cols))
+    R = CartesianRange(indices(mag))
+    for i in R
+        trilinear_interpolate!(hist, mag[i], phase[i], orientations, i, cell_size, cell_rows, cell_cols, rows, cols)
+    end
+
+    function normalize(v, method)
+        if method == "L2-norm"
+            return v./sqrt(sum(abs2, v) + 1e-5)
+        elseif method == "L2-hys"
+            v = v./(sum(abs2, v) + 1e-5)
+            v = min.(v, 0.2)
+            return v./(sum(abs2, v) + 1e-5)
+        elseif method == "L1-norm"
+            return v./(sum(abs, v) + 1e-5)
+        elseif method == "L1-sqrt"
+            return sqrt.(v./(sum(abs, v) + 1e-5))
+        end
+    end
+
+    #contrast normalization for each block
+    descriptor_size::Int = ((cell_rows-block_size)/block_stride + 1) * ((cell_cols-block_size)/block_stride + 1) * (block_size*block_size) * orientations
+    descriptor = Vector{Float64}(descriptor_size)
+    block_vector_size = block_size * block_size * orientations
+    k = 1
+    for j in 1:block_stride:cell_cols-block_size+1
+        for i in 1:block_stride:cell_rows-block_size+1
+            descriptor[block_vector_size*(k-1)+1 : block_vector_size*k] = normalize(hist[:, i:i+block_size-1, j:j+block_size-1][:], params.norm_method)
+            k += 1
+        end
+    end
+
+    return descriptor
+end
+
+function trilinear_interpolate!(hist, w, θ, orientations, i, cell_size, cell_rows, cell_cols, rows, cols)
+    bin_θ1 = floor(Int, θ*orientations/180) + 1
+    bin_θ2 = bin_θ1%orientations + 1
+    b_θ = 180/orientations
+
+    if bin_θ1 != orientations
+        θ1 = (bin_θ1-1)*180/orientations
+        θ2 = (bin_θ2-1)*180/orientations
+    else
+        θ1 = (bin_θ1-1)*180/orientations
+        θ2 = 180;
+    end
+
+    if (i[1]<=cell_size/2 || i[1]>=rows-cell_size/2) && (i[2]<=cell_size/2 || i[2]>=cols-cell_size/2)
+        #linear interpolation for corner points
+        bin_x = i[1] < cell_size/2 ? 1 : cell_rows
+        bin_y = i[2] < cell_size/2 ? 1 : cell_cols
+
+        hist[bin_θ1, bin_x, bin_y] += w*(1-(θ-θ1)/b_θ)
+        hist[bin_θ2, bin_x, bin_y] += w*(1-(θ2-θ)/b_θ)
+
+    elseif i[1]<=cell_size/2 || i[1]>=rows-cell_size/2
+        #bilinear interpolation for (top/bottom) edge points
+        bin_x = i[1] < cell_size/2 ? 1 : cell_rows
+        bin_y1 = floor(Int, (i[2]+cell_size/2)/cell_size)
+        bin_y2 = bin_y1 + 1
+
+        y1 = (bin_y1-1)*cell_size+cell_size/2
+        y2 = (bin_y2-1)*cell_size+cell_size/2
+        b_y = cell_size
+
+        hist[bin_θ1, bin_x, bin_y1] += w*(1-(θ-θ1)/b_θ)*(1-(i[2]-y1)/b_y)
+        hist[bin_θ1, bin_x, bin_y2] += w*(1-(θ-θ1)/b_θ)*(1-(y2-i[2])/b_y)
+        hist[bin_θ2, bin_x, bin_y1] += w*(1-(θ2-θ)/b_θ)*(1-(i[2]-y1)/b_y)
+        hist[bin_θ2, bin_x, bin_y2] += w*(1-(θ2-θ)/b_θ)*(1-(y2-i[2])/b_y)
+
+    elseif  i[2]<=cell_size/2 || i[2]>=cols-cell_size/2
+        #bilinear interpolation for (left/right) edge points
+        bin_x1 = floor(Int, (i[1]+cell_size/2)/cell_size)
+        bin_x2 = bin_x1 + 1
+        bin_y = i[2] < cell_size/2 ? 1 : cell_cols
+
+        x1 = (bin_x1-1)*cell_size+cell_size/2
+        x2 = (bin_x2-1)*cell_size+cell_size/2
+        b_x = cell_size
+
+        hist[bin_θ1, bin_x1, bin_y] += w*(1-(θ-θ1)/b_θ)*(1-(i[1]-x1)/b_x)
+        hist[bin_θ1, bin_x2, bin_y] += w*(1-(θ-θ1)/b_θ)*(1-(x2-i[1])/b_x)
+        hist[bin_θ2, bin_x1, bin_y] += w*(1-(θ2-θ)/b_θ)*(1-(i[1]-x1)/b_x)
+        hist[bin_θ2, bin_x2, bin_y] += w*(1-(θ2-θ)/b_θ)*(1-(x2-i[1])/b_x)
+    else
+        #trilinear interpolation
+        bin_x1 = floor(Int, (i[1]+cell_size/2)/cell_size)
+        bin_x2 = bin_x1 + 1
+        bin_y1 = floor(Int, (i[2]+cell_size/2)/cell_size)
+        bin_y2 = bin_y1 + 1
+
+        x1 = (bin_x1-1)*cell_size+cell_size/2
+        x2 = (bin_x2-1)*cell_size+cell_size/2
+        b_x = cell_size
+
+        y1 = (bin_y1-1)*cell_size+cell_size/2
+        y2 = (bin_y2-1)*cell_size+cell_size/2
+        b_y = cell_size
+
+        hist[bin_θ1, bin_x1, bin_y1] += w*(1-(θ-θ1)/b_θ)*(1-(i[1]-x1)/b_x)*(1-(i[2]-y1)/b_y)
+        hist[bin_θ1, bin_x1, bin_y2] += w*(1-(θ-θ1)/b_θ)*(1-(i[1]-x1)/b_x)*(1-(y2-i[2])/b_y)
+        hist[bin_θ1, bin_x2, bin_y1] += w*(1-(θ-θ1)/b_θ)*(1-(x2-i[1])/b_x)*(1-(i[2]-y1)/b_y)
+        hist[bin_θ1, bin_x2, bin_y2] += w*(1-(θ-θ1)/b_θ)*(1-(x2-i[1])/b_x)*(1-(y2-i[2])/b_y)
+        hist[bin_θ2, bin_x1, bin_y1] += w*(1-(θ2-θ)/b_θ)*(1-(i[1]-x1)/b_x)*(1-(i[2]-y1)/b_y)
+        hist[bin_θ2, bin_x1, bin_y2] += w*(1-(θ2-θ)/b_θ)*(1-(i[1]-x1)/b_x)*(1-(y2-i[2])/b_y)
+        hist[bin_θ2, bin_x2, bin_y1] += w*(1-(θ2-θ)/b_θ)*(1-(x2-i[1])/b_x)*(1-(i[2]-y1)/b_y)
+        hist[bin_θ2, bin_x2, bin_y2] += w*(1-(θ2-θ)/b_θ)*(1-(x2-i[1])/b_x)*(1-(y2-i[2])/b_y)
+    end
+end

test/hog.jl

@@ -0,0 +1,31 @@
+using Base.Test, ImageFeatures, Images
+import ImageFeatures.trilinear_interpolate!
+
+@testset "HOG Feature" begin
+    img = rand(128, 64)
+    @test length(create_descriptor(img, HOG())) == 3780
+
+    img = rand(RGB, 128, 64)
+    @test length(create_descriptor(img, HOG())) == 3780
+
+    #tests for function trilinear_interpolate!
+    rows = 12
+    cols = 12
+    cell_size = 4
+    cell_rows::Int = rows/cell_size
+    cell_cols::Int = cols/cell_size
+    orientations = 9
+
+    hist = zeros(9, 3, 3)
+    trilinear_interpolate!(hist, 1, 170, orientations, CartesianIndex(1, 1), cell_size, cell_rows, cell_cols, rows, cols)
+    @test hist[1, 1, 1] == hist[9, 1, 1] == 0.5
+
+    hist = zeros(9, 3, 3)
+    trilinear_interpolate!(hist, 1, 150, orientations, CartesianIndex(1, 4), cell_size, cell_rows, cell_cols, rows, cols)
+    @test hist[8, 1, 1] == hist[9, 1, 1] == hist[8, 1, 2] == hist[9, 1, 2] == 0.25
+
+    hist = zeros(9, 3, 3)
+    trilinear_interpolate!(hist, 1, 145, orientations, CartesianIndex(4, 4), cell_size, cell_rows, cell_cols, rows, cols)
+    @test hist[8, 1, 1] == hist[8, 1, 2] == hist[8, 2, 1] == hist[8, 2, 2] == 0.1875
+    @test hist[9, 1, 1] == hist[9, 1, 2] == hist[9, 2, 1] == hist[9, 2, 2] == 0.0625
+end

test/runtests.jl

@@ -56,6 +56,7 @@ tests = [
     "freak.jl",
     "brisk.jl",
     "houghtransform.jl",
+    "hog.jl"
 ]
 
 for t in tests