[WIP]Add boosting tracker

Project.toml

@@ -1,2 +1,30 @@
+name = "ImageTracking"
+uuid = "5cb2747a-620a-11e9-38cd-3dc946e3e5f7"
+version = "0.1.0"
+
 [deps]
+AxisAlgorithms = "13072b0f-2c55-5437-9ae7-d433b7a33950"
+CoordinateTransformations = "150eb455-5306-5404-9cee-2592286d6298"
+ImageFiltering = "6a3955dd-da59-5b1f-98d4-e7296123deb5"
+Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+Interpolations = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+
+[compat]
+AxisAlgorithms = ">= 0.2"
+ImageFiltering = ">= 0.3"
+Images = ">= 0.17"
+Interpolations = ">= 0.7"
+julia = ">= 0.7"
+
+[extras]
+ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
+QuartzImageIO = "dca85d43-d64c-5e67-8c65-017450d5d020"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+TestImages = "5e47fb64-e119-507b-a336-dd2b206d9990"
+
+[targets]
+test = ["Test", "TestImages", "ImageMagick", "QuartzImageIO"]

src/ImageTracking.jl

@@ -25,6 +25,7 @@ include("core.jl")
 include("optical_flow.jl")
 include("haar.jl")
 include("utility.jl")
+include("tracker/tracker.jl")
 
 export
 
@@ -54,8 +55,13 @@ export
 
     # types that select implementation
     ConvolutionImplementation,
-    MatrixImplementation
-
+    MatrixImplementation,
 
+    # tracking algorithms
+    BoxROI,
+    CurrentSampler,
+    TrackerBoosting,
+    initialize!,
+    update!
 
 end

src/core.jl

@@ -30,3 +30,23 @@ function pinv2x2(M::AbstractArray)
      D = SMatrix{2,2,Float64}( S[1,1] > tol ?  1/S[1,1] : 0.0 , 0.0, 0.0, S[2,2] > tol ?  1/S[2,2] : 0.0 )
      U*D*V'
 end
+
+abstract type AbstractTrackerTargetState end
+mutable struct BoostingTrackerTargetState <: AbstractTrackerTargetState
+    #Initialized
+    position::SVector{2, Float64}
+    height::Integer
+    width::Integer
+    is_target::Bool
+
+    #Uninitialized
+    responses::Array{T, 2} where T
+    BoostingTrackerTargetState(position::SVector{2, Float64}, height::Integer, width::Integer, is_target::Bool) =
+    new(position, height, width, is_target)
+end
+
+
+mutable struct ConfidenceMap{T <: AbstractTrackerTargetState, F <: AbstractFloat}
+    states::Vector{T}
+    confidence::Vector{F}
+end

src/tracker/boosting_tracker.jl

@@ -0,0 +1,29 @@
+#-----------------------------------
+# Implementation of boosting tracker
+#-----------------------------------
+
+function initialize!(tracker::TrackerBoosting)
+    int_image = integral_image(tracker.box.img)
+
+    # sampling
+    int_box = BoxROI(int_image, tracker.box.bound)
+
+    tracker.sampler.mode = :positive
+    positive_samples = sample_roi(tracker.sampler, int_box)
+
+    tracker.sampler.mode = :negative
+    negative_samples = sample_roi(tracker.sampler, int_box)
+
+    if isempty(positive_samples) || isempty(negative_samples)
+        error("Couldn't get initial samples")
+    end
+    # compute harr haar_features
+
+    # model
+
+    # Run model estimation and update for initial iterations
+end
+
+function update!(tracker::TrackerBoosting, image::AbstractArray)
+
+end

src/tracker/tracker.jl

@@ -0,0 +1,57 @@
+#---------------------
+# TRACKER COMPONENTS
+#---------------------
+
+include("../core.jl")
+include("tracker_sampler.jl")
+# include("tracker_state_estimator.jl")
+# include("tracker_model.jl")
+# include("tracker_features.jl")
+
+abstract type AbstractTracker end
+mutable struct TrackerBoosting{I <: Integer, B <: BoxROI, CS <: CurrentSampler} <: AbstractTracker
+    # initialized
+    box::B
+    sampler::CS
+    num_of_classifiers::I
+    initial_iterations::I
+    num_of_features::I
+
+    # constructor
+    function TrackerBoosting{I, B, CS}(box::B, sampler::CS, num_of_classifiers::I = 100, initial_iterations::I = 20,
+        num_of_features::I = 1050)where {I <: Integer, B <: BoxROI, CS <: CurrentSampler}
+        if size(box.bound, 1) != 4
+            error("Invalid bounding box size")
+        end
+
+        if box.bound[1] < 1 && box.bound[1] > size(box.img)[1]
+            error("Invalid bounding box")
+        end
+        if box.bound[2] < 1 && box.bound[2] > size(box.img)[2]
+            error("Invalid bounding box")
+        end
+        if box.bound[3] < 1 && box.bound[3] > size(box.img)[1]
+            error("Invalid bounding box")
+        end
+        if box.bound[4] < 1 && box.bound[4] > size(box.img)[2]
+            error("Invalid bounding box")
+        end
+
+        if box.bound[1] > box.bound[3]
+            error("Invalid bounding box")
+        end
+        if box.bound[2] > box.bound[4]
+            error("Invalid bounding box")
+        end
+        new(box, sampler, num_of_classifiers, initial_iterations, num_of_features)
+    end
+end
+
+TrackerBoosting(box::B, sampler::CS, num_of_classifiers::I, initial_iterations::I, num_of_features::I) where{I <: Integer, B <: BoxROI, CS <: CurrentSampler} = TrackerBoosting{I, B, CS}(box, sampler, num_of_classifiers, initial_iterations, num_of_features)
+
+
+#------------------
+# IMPLEMENTATIONS
+#------------------
+
+include("boosting_tracker.jl")

src/tracker/tracker_sampler.jl

@@ -0,0 +1,100 @@
+abstract type AbstractROI end
+mutable struct BoxROI{T <: AbstractArray, S <: AbstractArray} <: AbstractROI
+    img::T
+    bound::S
+end
+
+abstract type AbstractTrackerSampler end
+mutable struct CurrentSampler{F <: AbstractFloat} <: AbstractTrackerSampler
+    overlap::F
+    search_factor::F
+    mode::S where S <: Symbol
+    sampling_region::SVector{4, Integer}
+    valid_region::SVector{4, Integer}
+    tracked_patch::SVector{4, Integer}
+    CurrentSampler{F}(overlap, search_factor) where{F <: AbstractFloat} = new(overlap, search_factor)
+end
+
+CurrentSampler(overlap::F = 0.99, search_factor::F = 1.8) where{F <: AbstractFloat} = CurrentSampler{F}(overlap, search_factor)
+
+function sample_roi(sampler::CurrentSampler, box::BoxROI)
+    sampler.tracked_patch = box.bound
+    sampler.valid_region = SVector{4, Integer}([1, 1, size(box.img, 1), size(box.img, 2)])
+
+    height = box.bound[3] - box.bound[1] + 1
+    width = box.bound[4] - box.bound[2] + 1
+
+    sampling_region_min_y = max(0, floor(Integer, box.bound[1] - height*((sampler.search_factor - 1) / 2) + 1))
+    sampling_region_min_x = max(0, floor(Integer, box.bound[2] - width*((sampler.search_factor - 1) / 2) + 1))
+
+    sampling_region_height = min(floor(Integer, height*sampler.search_factor), size(box.img, 1) - sampling_region_min_y + 1)
+    sampling_region_width = min(floor(Integer, width*sampler.search_factor), size(box.img, 2) - sampling_region_min_x + 1)
+
+    sampling_region_max_y = sampling_region_min_y + sampling_region_height - 1
+    sampling_region_max_x = sampling_region_min_x + sampling_region_width - 1
+
+    sampling_region = SVector{4, Integer}([sampling_region_min_y, sampling_region_min_x, sampling_region_max_y, sampling_region_max_x])
+
+    sample_mode_roi(sampler, box, sampling_region)
+end
+
+function sample_mode_roi(sampler::CurrentSampler, box::BoxROI, sampling_region::SVector{4, Integer})
+    if sampler.valid_region == sampling_region
+        sampler.sampling_region = sampling_region
+    else
+        sampler.sampling_region = SVector{4, Integer}(max(sampler.valid_region[1], sampling_region[1]), max(sampler.valid_region[2],sampling_region[2]),
+        min(sampler.valid_region[3], sampling_region[3]), min(sampler.valid_region[4], sampling_region[4]))
+    end
+
+    if sampler.mode == :positive
+        positive_sample = box.img[sampler.tracked_patch[1]:sampler.tracked_patch[3],
+         sampler.tracked_patch[2]:sampler.tracked_patch[4]]
+        positive_sample_pos = SVector{2, Integer}(sampler.tracked_patch[1], sampler.tracked_patch[2])
+        samples = fill((positive_sample, positive_sample_pos), (1, 4))
+
+        return samples
+    end
+
+    height = sampler.tracked_patch[3] - sampler.tracked_patch[1] + 1
+    width = sampler.tracked_patch[4] - sampler.tracked_patch[2] + 1
+
+    tl_block = SVector{4, Integer}(sampler.sampling_region[1], sampler.sampling_region[2], sampler.sampling_region[1] + height - 1,
+    sampler.sampling_region[2] + width - 1)
+    tr_block = SVector{4, Integer}(sampler.sampling_region[1], sampler.sampling_region[4] - width + 1, sampler.sampling_region[1] + height - 1,
+    sampler.sampling_region[4])
+    bl_block = SVector{4, Integer}(sampler.sampling_region[3] - height + 1, sampler.sampling_region[2], sampler.sampling_region[3],
+    sampler.sampling_region[2] + width - 1)
+    br_block = SVector{4, Integer}(sampler.sampling_region[3] - height + 1, sampler.sampling_region[4] - width + 1, sampler.sampling_region[3],
+    sampler.sampling_region[4])
+
+    if sampler.mode == :negative
+        tl_sample = box.img[tl_block[1]:tl_block[3], tl_block[2]:tl_block[4]]
+        tr_sample = box.img[tr_block[1]:tr_block[3], tr_block[2]:tr_block[4]]
+        bl_sample = box.img[bl_block[1]:bl_block[3], bl_block[2]:bl_block[4]]
+        br_sample = box.img[br_block[1]:br_block[3], br_block[2]:br_block[4]]
+        samples = [(tl_sample, SVector{2, Integer}(tl_block[1:2])) (tr_sample, SVector{2, Integer}(tr_block[1:2])) (bl_sample, SVector{2, Integer}(bl_block[1:2])) (br_sample, SVector{2, Integer}(br_block[1:2]))]
+
+        return samples
+    end
+
+    if sampler.mode == :classify
+        step_row = max(1, floor(Int, (1 - sampler.overlap)*height + 0.5))
+        step_col = max(1, floor(Int, (1 - sampler.overlap)*width + 0.5))
+        max_row = sampler.sampling_region[3] - sampler.sampling_region[1] - height + 1
+        max_col = sampler.sampling_region[4] - sampler.sampling_region[2] - width + 1
+
+        samples = Array{Tuple{Array{T, 2}, SVector{2, Integer}}} where T <: Integer
+        for i = 1:step_col:max_col
+            for j = 1:step_row:max_row
+                push!(samples, (box.img[j + sampler.sampling_region[1] - 1:j + sampler.sampling_region[1] + height - 2,
+                i + sampler.sampling_region[2] - 1:i + sampler.sampling_region[2] + width - 2],
+                SVector{2, Integer}(j + sampler.sampling_region[1]-1, i + sampler.sampling_region[2]-1)))
+            end
+        end
+
+        return samples
+    else
+        error("Incorrect mode.")
+    end
+
+end

test/runtests.jl

@@ -1,10 +1,9 @@
 using ImageTracking
 using Test
 
-
 include("farneback.jl")
 include("lucas_kanade.jl")
 include("haar.jl")
 include("visualization.jl")
 include("error_evaluation.jl")
-
+include("tracker/sample_roi.jl")

test/tracker/sample_roi.jl

@@ -0,0 +1,28 @@
+using Images
+using ImageTracking:sample_roi
+
+@testset "ROI sampling" begin
+    @info "Running ROI sampling tests"
+    box = BoxROI(ones(300, 300), [125, 125, 175, 175])
+    sampler_overlap = 0.5
+    search_factor = 2.0
+    int_img = integral_image(box.img)
+    currentsample = CurrentSampler(sampler_overlap, search_factor)
+    # positive sampling
+    currentsample.mode = :positive
+    @time samples = sample_roi(currentsample, BoxROI(int_img, box.bound))
+
+    @test size(samples) == (1, 4)
+    @test samples[1][1] == int_img[125:175, 125:175]
+
+    # negative sampling
+    currentsample.mode = :negative
+    @time samples = sample_roi(currentsample, BoxROI(int_img, box.bound))
+
+    @test size(samples) == (1, 4)
+    @test samples[1][1] == int_img[100:150, 100:150]
+    @test samples[2][1] == int_img[100:150, 151:201]
+    @test samples[3][1] == int_img[151:201, 100:150]
+    @test samples[4][1] == int_img[151:201, 151:201]
+
+end;