Internal Documentation

add_figs_pflap(figs, level, iter_repeat, u_est, Δ_u, source_reg, level_count, max_repeats)

Fill the figs array specifically for the pflap method.

function angle_mae(x, y)

Calculate the mean absolute error in angle between x and y. Output in degrees.

function angle_rmse(x, y)

Calculate the root mean square error in angle between x and y. Output in degrees.

back_substitution3d(A, b)

Solve the linear systems of equations $C_n x_n = d_n$, where the matrixes $C$ (in row echelon form) are slices from the first 2 dimensions of A, the vectors $d$ are the slices from the first dimension of b and $n$ is the size of the third dimension of A. Returns the coefficients $x_n$ as a 2D matrix coeffs, where the vectors $x_n$ are the rows of this matrix.

See also: gem3d!, multi_mat_div_gem

compare_dicts(old_dict, new_dict)

Compare two dicts by dividing their corresponding values, return the comparation dict.

Note: (old / new)

cumsum2d!(result, A)

Cummulative sum over 2D matrix A, storing the result into result.

estimation_noise_variance(img::Image)

Estimate the noise variance of an image y, by evaluating the Median of its Absolute Difference.

Note: Implementation in matlab by Thierry Blu, the Chinese University of Hong kong, Shatin, Hong Kong

fill_circle!(mag, pos, spacing, marker)

Fill a circle with a radius of spacing around the point pos into the matrix mag with marker.

filter_border_inds(inds, img_size, border_width)

Filter out the CartesianIndices inds that are within the border_width of an image of size img_size.

fun_on_dict_values(dicts, fun)

Run function fun on all same keys of all dictionaries dicts.

using BenchmarkTools
fun_on_dict_values((Dict(:a => 1), Dict(:a => 12)), mean)

# output

Dict{Any,Any} with 1 entry:
  :a => 6.5

gem3d!(A, b)

Reduce the linear systems of equations $C_n x_n = d_n$ to the row echelon form. The matrixes $C$ are slices from the first 2 dimensions of A, the vectors $d$ are the slices from the first dimension of b and $n$ is the size of the third dimension of A.

See also: gem3d!, back_substitution3d

gen_one_spaghetti(img_size, τ, len, spread)

Generate a single spaghetti image with the params τ (thickness), len (length) and spread. The coordinates x and y in the equation are scaled from (-1, 1) and the spread gives the length of interval in which the (-1, 1) is randomly located. The genereated spaghetti is also randomly rotated.

(Example for spread 10, the interval for x and y is randomly anywhere between (-9:1) and (-1:9))

The intensity is equal to:

where

a and b are chosen randomly from a normal distribution.

See also: gen_spaghetti, spaghetti_fun

gen_rand_points(flow, point_count, mode; max_skew_const=4)

Generate point_count random indices over flow depending on selection mode.

gradient_magnitude(f)

Return the directional derivatives (components of the gradient) and the gradient mag for both color and grayscale images. For spatialorder(f)=="xy", grad[1] is a derivative wrt x, the first coordinate and grad[2] wrt to the second...

highpass_image(img, window_half_size)

High-pass img with a hight-pass filter. This high-pass filter is 1-gaussian.

inds_to_points(inds::Array{CartesianIndex, 1})

Transform an array of CartersianIndexes to an array of where each column is a vector of indices of the input array.

inpaint_nans!(flow::Flow)

Inpaint NaNs in flow using surrounding non-NaN values.

References

Oliveira, Manuel & Bowen, Brian & McKenna, Richard & Chang, Yu-Sung. (2001). Fast Digital Image Inpainting.. 261-266. Here.

See also: showflow, Flow

interpolate_flow_rbf(flow_at_inds,
                     inds::Array{CartesianIndex, 1},
                     flow_size,
                     rbf_method::T=Multiquadratic(2)) where {T <: ScatteredInterpolation.RadialBasisFunction}

Interpolate a complex displacement field of size flow_size from displacement vectors flow_at_inds at inds using the a Multiquadratic RBF model with the parameter ε and using only the values at inds for the interpolation.

Examples of method from ScatteredInterpolation:

Multiquadratic(ɛ = 1)

Polyharmonic(k = 1)

(See ScatteredInterpolation for more.)

See also: showflow, Flow, interpolate_flow, interpolate_flow_quad

load_H(path)

Load a homography matrix from path path

make_flow_from_H(H, size)

Make a flow of size size from the homography matrix H.

mapped_out(flow)

Return a mask that has true at the locations where flow would take the pixel out bounds of the image size.

max_displacement(flow)

Find the maximum displacement of flow, ignoring NaNs.

move_landmarks(locations, flow)

Move each location::Tuple(T,T) where T <: Real from the locations vector using the flow.

multi_mat_div_gem(A, b)

Solve the linear systems of equations $C_n x_n = d_n$, where the matrixes $C$ are slices from the first 2 dimensions of A, the vectors $d$ are the slices from the first dimension of b and $n$ is the size of the third dimension of A. Returns the coefficients $x_n$ as a 2D matrix coeffs, where the vectors $x_n$ are the rows of this matrix.

Note: Uses Gaussian elimination and back substitution. Note: For small matrices $C$, this is an order of magnitude faster than

See also: gem3d!, back_substitution3d

multi_mat_div_using_qr(A, b)

Return E, where E[i, :] is the solutution of the least squares problem $\min\|D_ix - c_i\|^2$ for each $D_i$ and $c_i$, where $D_i$ is A[:, :, i], $c_i$ is b[:, i] and $i$ is the size of the second dimension of b and third dimension of A. In other words, each row of E is the solution to one matrix from A and it's corresponding vector from b.

normalize_to_zero_one(arr)

Normalize arr so that it has a maximum of 1 and minimum of 0.

pad_images(image1::Image, image2::Image)

Adds zeros to the right and bottom of image1 and image2 to make them the same size.

pad_images(image1::Image, image2::Image)

Adds zeros to the right and bottom of image1 and image2 to make them the same size. Also create a mask, which has zeros at the edges of added zeros.

points_to_inds(points::Array{Int64,2})

Reverse of the inds_to_points function.

prepare_gaussian_filters(filter_half_size)

Get KernelFactors for the first 3 forward and backward gaussian filters from the LAP paper.

rescale!(image1::Image, image2::Image)

Rescale image1 and image2 intensities to span the whole [0, 1].

smooth_with_gaussian!(A::Matrix{<:Number}, window_half_size_one_dim::Integer)

Clean the Matrix A by smoothing using a square 2D Gaussian filter of size 2 * window_half_size_one_dim + 1 in each dimension.

smooth_with_gaussian!(A::Matrix{<:Number}, window_half_size)

Smooth the Matrix A by smoothing using a 2D Gaussian filter of size 2 * window_half_size + 1.

spaghetti_fun(x, y, a, b, τ, len)

Gives the intensity for a single "spaghetti" at (x, y) with the params a, b, τ and len.

The intensity is equal to:

where

See also: gen_spaghetti, gen_one_spaghetti, gen_spaghetti

to_lin_index(cart_ind, size)

Get linear index from CartesianIndex cart_ind of 2D matrix of size size.

function vec_len(x)

Calculate the lenght of vector x. x is a complex number.

function window_sum!(result, pixels, img_size, window)

Get a sum of values (using a "symmetric" padding on the borders) in a window window around each point and saving the sum into result.

Note: Uses a filter algorithm with a 2D ones kernel. Note: For small images (around 256x256) and small filters (window of size 9 and below) is faster than window_sum3!. <- factcheck this again

function window_sum3!(result, pixels, img_size, window)

Get a sum of values (using a "symmetric" padding on the borders) in a window window around each point and saving the sum into result.

Note: Uses a cumsum algorithm. Note: For small images (around 256x256) and large filters (window of size 11 and above) is faster than window_sum!. <- factcheck this again

function window_sum3!(result, pixels, img_size, window, inds)

Get a sum of values (using a "symmetric" padding on the borders) in a window window around inds and saving the sum into result.

Note: Uses a cumsum algorithm.