feature = Feature(keypoint, orientation = 0.0, scale = 0.0)

The Feature type has the keypoint, its orientation and its scale.

features = Features(boolean_img)
features = Features(keypoints)

Returns a Vector{Feature} of features generated from the true values in a boolean image or from a list of keypoints.

keypoint = Keypoint(y, x)
keypoint = Keypoint(feature)

A Keypoint may be created by passing the coordinates of the point or from a feature.

keypoints = Keypoints(boolean_img)
keypoints = Keypoints(features)

Creates a Vector{Keypoint} of the true values in a boolean image or from a list of features.

brief_params = BRIEF([size = 128], [window = 9], [sigma = 2 ^ 0.5], [sampling_type = gaussian], [seed = 123])

orb_params = ORB([num_keypoints = 500], [n_fast = 12], [threshold = 0.25], [harris_factor = 0.04], [downsample = 1.3], [levels = 8], [sigma = 1.2])

freak_params = FREAK([pattern_scale = 22.0])

brisk_params = BRISK([pattern_scale = 1.0])

orientations = corner_orientations(img)
orientations = corner_orientations(img, corners)
orientations = corner_orientations(img, corners, kernel)

Returns the orientations of corner patches in an image. The orientation of a corner patch is denoted by the orientation of the vector between intensity centroid and the corner. The intensity centroid can be calculated as C = (m01/m00, m10/m00) where mpq is defined as -

`mpq = (x^p)(y^q)I(y, x) for each p, q in the corner patch`

The kernel used for the patch can be given through the kernel argument. The default kernel used is a gaussian kernel of size 5x5.

sample_one, sample_two = random_uniform(size, window, seed)

Builds sampling pairs using random uniform sampling.

sample_one, sample_two = random_coarse(size, window, seed)

Builds sampling pairs using random sampling over a coarse grid.

sample_one, sample_two = gaussian(size, window, seed)

Builds sampling pairs using gaussian sampling.

sample_one, sample_two = gaussian_local(size, window, seed)

Pairs (Xi, Yi) 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

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.

desc, keypoints = create_descriptor(img, keypoints, params)
desc, keypoints = create_descriptor(img, params)

Create a descriptor for each entry in keypoints from the image img. params specifies the parameters for any of several descriptors:

• BRIEF
• ORB
• BRISK
• FREAK
• HOG

Some descriptors support discovery of the keypoints from fastcorners.

distance = hamming_distance(desc_1, desc_2)

Calculates the hamming distance between two descriptors.

matches = match_keypoints(keypoints_1, keypoints_2, desc_1, desc_2, threshold = 0.1)

Finds matched keypoints using the hamming_distance function having distance value less than threshold.

lines = hough_transform_standard(
    img_edges::AbstractMatrix;
    stepsize=1,
    angles=range(0,stop=pi,length=minimum(size(img))),
    vote_threshold=minimum(size(img)) / stepsize -1,
    max_linecount=typemax(Int))

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

The lines are generated by applying hough transform on the image.

Parameters:

• img_edges = Image to be transformed (eltype should be Bool)
• stepsize = Discrete step size for perpendicular length of line
• angles = List of angles for which the transform is computed
• vote_threshold = Accumulator threshold for line detection
• max_linecount = Maximum no of lines to return

Example

julia> using ImageFeatures

julia> img = fill(false,5,5); img[3,:] .= true; img
5×5 Array{Bool,2}:
 false  false  false  false  false
 false  false  false  false  false
  true   true   true   true   true
 false  false  false  false  false
 false  false  false  false  false

julia> hough_transform_standard(img)
1-element Array{Tuple{Float64,Float64},1}:
 (3.0, 1.5707963267948966)

circle_centers, circle_radius = hough_circle_gradient(img_edges, img_phase, radii; scale=1, min_dist=minimum(radii), vote_threshold)

Returns two vectors, corresponding to circle centers and radius.

The circles are generated using a hough transform variant in which a non-zero point only votes for circle centers perpendicular to the local gradient. In case of concentric circles, only the largest circle is detected.

Parameters:

• img_edges = edges of the image
• img_phase = phase of the gradient image
• radii = circle radius range
• scale = relative accumulator resolution factor
• min_dist = minimum distance between detected circle centers
• vote_threshold = accumulator threshold for circle detection

canny and phase can be used for obtaining imgedges and imgphase respectively.

Example

julia> using Images, ImageFeatures, FileIO, ImageView

julia> img = load(download("http://docs.opencv.org/3.1.0/water_coins.jpg"));

julia> img = Gray.(img);

julia> img_edges = canny(img, (Percentile(99), Percentile(80)));

julia> dx, dy=imgradients(img, KernelFactors.ando5);

julia> img_phase = phase(dx, dy);

julia> centers, radii = hough_circle_gradient(img_edges, img_phase, 20:30);

julia> img_demo = Float64.(img_edges); for c in centers img_demo[c] = 2; end

julia> imshow(img_demo)