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.

fastcorners(img, n, threshold) -> corners

Performs FAST Corner Detection. n is the number of contiguous pixels which need to be greater (lesser) than intensity + threshold (intensity - threshold) for a pixel to be marked as a corner. The default value for n is 12.

canny_edges = canny(img, (upper, lower), sigma=1.4)

Performs Canny Edge Detection on the input image.

Parameters :

(upper, lower) : Bounds for hysteresis thresholding sigma : Specifies the standard deviation of the gaussian filter

Example

imgedg = canny(img, (Percentile(80), Percentile(20)))

phase(grad_x, grad_y) -> p

Calculate the rotation angle of the gradient given by grad_x and grad_y. Equivalent to atan(-grad_y, grad_x), except that when both grad_x and grad_y are effectively zero, the corresponding angle is set to zero.

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.

glcm = glcm(img, distance, angle, mat_size=16)
glcm = glcm(img, distances, angle, mat_size=16)
glcm = glcm(img, distance, angles, mat_size=16)
glcm = glcm(img, distances, angles, mat_size=16)

Calculates the GLCM (Gray Level Co-occurrence Matrix) of an image. The distances and angles arguments may be a single integer or a vector of integers if multiple GLCMs need to be calculated. The mat_size argument is used to define the granularity of the GLCM.

glcm = glcm_symmetric(img, distance, angle, mat_size=16)
glcm = glcm_symmetric(img, distances, angle, mat_size=16)
glcm = glcm_symmetric(img, distance, angles, mat_size=16)
glcm = glcm_symmetric(img, distances, angles, mat_size=16)

Symmetric version of the glcm function.

glcm = glcm_norm(img, distance, angle, mat_size)
glcm = glcm_norm(img, distances, angle, mat_size)
glcm = glcm_norm(img, distance, angles, mat_size)
glcm = glcm_norm(img, distances, angles, mat_size)

Normalised version of the glcm function.

Multiple properties of the obtained GLCM can be calculated by using the glcm_prop function which calculates the property for the entire matrix. If grid dimensions are provided, the matrix is divided into a grid and the property is calculated for each cell resulting in a height x width property matrix.

prop = glcm_prop(glcm, property)
prop = glcm_prop(glcm, height, width, property)

Various properties can be calculated like mean, variance, correlation, contrast, IDM (Inverse Difference Moment), ASM (Angular Second Moment), entropy, max_prob (Max Probability), energy and dissimilarity.

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 descriptor usually used for object detection. See "Histograms of Oriented Gradients for Human Detection" by Dalal and Triggs.

Parameters:

• orientations = number of orientation bins
• cellsize = size of a cell is cellsize x cell_size (in pixels)
• blocksize = size of a block is blocksize 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.

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)