IceFloeTracker

Documentation for IceFloeTracker.jl package.

IceFloeTracker
- Functions
- Index

Functions

Base.isequal — Method

isequal(matchedpairs1::MatchedPairs, matchedpairs2::MatchedPairs)

Return true if matchedpairs1 and matchedpairs2 are equal, false otherwise.

source

IceFloeTracker._adjust_histogram — Method

_adjust_histogram(masked_view, nbins, rblocks, cblocks, clip)

Perform adaptive histogram equalization to a masked image. To be invoked within imsharpen.

Arguments

masked_view: input image in truecolor

See imsharpen for a description of the remaining arguments

source

IceFloeTracker._bin9todec — Method

_bin9todec(v)

Get decimal representation of a bit vector v with the leading bit at its leftmost posistion.

Example

julia> _bin9todec([0 0 0 0 0 0 0 0 0])    
0

julia> _bin9todec([1 1 1 1 1 1 1 1 1])    
511

source

IceFloeTracker._branch_filter — Function

_branch_filter(
img::AbstractArray{Bool},
func1::Function=branch_candidates_func,
func2::Function=connected_background_count,)

Filter img with _operator_lut using lut1 and lut2.

source

IceFloeTracker._operator_lut — Method

_operator_lut(I, img, nhood, lut1, lut2)

Look up the neighborhood nhood in lookup tables lut1 and lut2.

Handles cases when the center of nhood is on the edge of img using data in I.

source

IceFloeTracker.absdiffmeanratio — Method

absdiffmeanratio(x, y)

Calculate the absolute difference between x and y divided by the mean of x and y.

source

IceFloeTracker.add_padding — Method

add_padding(img, style)

Extrapolate the image img according to the style specifications type. Returns the extrapolated image.

Arguments

img: Image to be padded.
style: A supported type (such as Pad or Fill) representing the extrapolation style. See the relevant documentation for details.

See also bwareamaxfilt

source

IceFloeTracker.bwdist — Method

bwdist(bwimg)

Distance transform for binary image bwdist.

source

IceFloeTracker.bwperim — Method

bwperim(bwimg)

Locate the pixels at the boundary of objects in an binary image bwimg using 8-pixel connectivity.

Arguments

bwimg: Binary (black/white – 1/0) image

Examples

julia> A = zeros(Bool, 13, 16); A[2:6, 2:6] .= 1; A[4:8, 7:10] .= 1; A[10:12,13:15] .= 1; A[10:12,3:6] .= 1;

julia> A
13×16 Matrix{Bool}:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

 julia> bwperim(A)
13×16 Matrix{Bool}:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  0  0  0  0  0  0  0  0  0  0
 0  1  0  0  0  1  0  0  0  0  0  0  0  0  0  0
 0  1  0  0  0  0  1  1  1  1  0  0  0  0  0  0
 0  1  0  0  0  0  0  0  0  1  0  0  0  0  0  0
 0  1  1  1  1  1  0  0  0  1  0  0  0  0  0  0
 0  0  0  0  0  0  1  0  0  1  0  0  0  0  0  0
 0  0  0  0  0  0  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  1  0  0  1  0  0  0  0  0  0  1  0  1  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

source

IceFloeTracker.bwtraceboundary — Method

bwtraceboundary(image::Union{Matrix{Int64},Matrix{Float64},T};
                P0::Union{Tuple{Int,Int},CartesianIndex{2},Nothing}=nothing,
                closed::Bool=true) where T<:AbstractMatrix{Bool}

Trace the boundary of objects in image

Background pixels are represented as zero. The algorithm traces the boundary counterclockwise and an initial point P0 can be specified. If more than one boundary is detected and an initial point is provided, the boundary that contains this point is returned as a vector of CartesianIndex types. Otherwise an array of vectors is returned with all the detected boundaries in image.

Arguments

image: image, preferably binary with one single object, whose objects' boundaries are to be traced.
P0: initial point of a target boundary.
closed: if true (default) makes the inital point of a boundary equal to the last point.

Example

julia> A = zeros(Int, 13, 16); A[2:6, 2:6] .= 1; A[4:8, 7:10] .= 1; A[10:12,13:15] .= 1; A[10:12,3:6] .= 1;

julia> A
13×16 Matrix{Int64}:
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  0  0  0  0  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  0  0  0  0  0  0
 0  1  1  1  1  1  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  1  1  1  1  0  0  0  0  0  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  1  1  1  1  0  0  0  0  0  0  1  1  1  0
 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

julia> boundary = IceFloeTracker.bwtraceboundary(A);

julia> boundary[3]
9-element Vector{CartesianIndex}:
 CartesianIndex(10, 13)
 CartesianIndex(11, 13)
 CartesianIndex(12, 13)
 CartesianIndex(12, 14)
 CartesianIndex(12, 15)
 CartesianIndex(11, 15)
 CartesianIndex(10, 15)
 CartesianIndex(10, 14)
 CartesianIndex(10, 13)

source

IceFloeTracker.callmatchcorr — Method

callmatchcorr(conditions)

Condition to decide whether match_corr should be called.

source

IceFloeTracker.check_fname — Function

check_fname(fname)

Checks fname does not exist in current directory; throws an assertion if this condition is false.

Arguments

fname: String object or Symbol to a reference to a String representing a path.

source

IceFloeTracker.clockwise — Method

Make a clockwise turn from the dir direction

source

IceFloeTracker.compute_ratios — Method

compute_ratios((props_day1, r), (props_day2,s))

Compute the ratios of the floe properties between the rth floe in props_day1 and the sth floe in props_day2. Return a tuple of the ratios.

Arguments

props_day1: floe properties for day 1
r: index of floe in props_day1
props_day2: floe properties for day 2
s: index of floe in props_day2

source

IceFloeTracker.compute_ratios_conditions — Method

compute_ratios_conditions((props_day1, r), (props_day2, s), delta_time, t)

Compute the conditions for a match between the rth floe in props_day1 and the sth floe in props_day2. Return a tuple of the conditions.

Arguments

props_day1: floe properties for day 1
r: index of floe in props_day1
props_day2: floe properties for day 2
s: index of floe in props_day2
delta_time: time elapsed from image day 1 to image day 2
t: tuple of thresholds for elapsed time and distance. See pair_floes for details.

source

IceFloeTracker.connected_background_count — Method

connected_background_count(nhood)

Second lut generator for neighbor transform with diamond strel (4-neighborhood).

To be passed to the make_lut function.

source

IceFloeTracker.convertcentroid! — Method

convertcentroid!(propdf, latlondata, colstodrop)

Convert the centroid coordinates from row and column to latitude and longitude dropping unwanted columns specified in colstodrop for the output data structure. Addionally, add columns x and y with the pixel coordinates of the centroid.

source

IceFloeTracker.converttounits! — Method

converttounits!(propdf, latlondata, colstodrop)

Convert the floe properties from pixels to kilometers and square kilometers where appropiate. Also drop the columns specified in colstodrop.

source

IceFloeTracker.corr — Method

corr(f1,f2)

Return the correlation between the psi-s curves p1 and p2.

source

IceFloeTracker.corr — Method

corr(f1,f2)

Return the normalized cross-correlation between the psi-s curves p1 and p2.

source

IceFloeTracker.counterclockwise — Method

Make a counterclockwise turn from the dir direction

source

IceFloeTracker.create_cloudmask — Method

create_cloudmask(falsecolor_image; prelim_threshold, band_7_threshold, band_2_threshold, ratio_lower, ratio_upper)

Convert a 3-channel false color reflectance image to a 1-channel binary matrix; clouds = 0, else = 1. Default thresholds are defined in the published Ice Floe Tracker article: Remote Sensing of the Environment 234 (2019) 111406.

Arguments

falsecolor_image: corrected reflectance false color image - bands [7,2,1]
prelim_threshold: threshold value used to identify clouds in band 7, N0f8(RGB intensity/255)
band_7_threshold: threshold value used to identify cloud-ice in band 7, N0f8(RGB intensity/255)
band_2_threshold: threshold value used to identify cloud-ice in band 2, N0f8(RGB intensity/255)
ratio_lower: threshold value used to set lower ratio of cloud-ice in bands 7 and 2
ratio_upper: threshold value used to set upper ratio of cloud-ice in bands 7 and 2

source

IceFloeTracker.create_landmask — Method

create_landmask(landmask_image, struct_elem, fill_value_lower, fill_value_upper)

Convert a 3-channel RGB land mask image to a 1-channel binary matrix, including a buffer to extend the land over any soft ice regions; land = 0, water/ice = 1. Returns a named tuple with the dilated and non-dilated landmask.

Arguments

landmask_image: RGB land mask image from fetchdata
struct_elem: structuring element for dilation (optional)
fill_value_lower: fill holes having at least these many pixels (optional)
fill_value_upper: fill holes having at most these many pixels (optional)

source

IceFloeTracker.cropfloe — Method

cropfloe(floesimg, props, i)

Crops the floe delimited by the bounding box data in props at index i from the floe image floesimg.

source

IceFloeTracker.crosscorr — Method

r, lags = crosscorr(u::Vector{T},
                    v::Vector{T};
                    normalize::Bool=false,
                    padmode::Symbol=:longest)

Wrapper of DSP.xcorr with normalization (see https://docs.juliadsp.org/stable/convolutions/#DSP.xcorr)

Returns the pair (r, lags) with the cross correlation scores r and corresponding lags according to padmode.

Arguments

u,v: real vectors which could have unequal length.
normalize: return normalized correlation scores (false by default).
padmode: either :longest (default) or :none to control padding of shorter vector with zeros.

Examples

The example below builds two vectors, one a shifted version of the other, and computes various cross correlation scores.

julia> n = 1:5;

julia> x = 0.48.^n;

julia> y = circshift(x,3);

julia> r, lags = crosscorr(x,y,normalize=true);

julia> [r lags]
9×2 Matrix{Float64}:
0.369648    -4.0
0.947531    -3.0
0.495695    -2.0
0.3231      -1.0
0.332519     0.0
0.15019      1.0
0.052469     2.0
0.0241435    3.0
0.00941878   4.0

julia> r, lags = crosscorr(x,y,normalize=true,padmode=:none);

julia> [r lags]
9×2 Matrix{Float64}:
0.369648    1.0
0.947531    2.0
0.495695    3.0
0.3231      4.0
0.332519    5.0
0.15019     6.0
0.052469    7.0
0.0241435   8.0
0.00941878  9.0

This final example builds two vectors of different length and computes some cross correlation scores.

julia> n = 1:5; m = 1:3;

julia> x = 0.48.^n; y = 0.48.^m;

julia> r, lags = crosscorr(x,y,normalize=true);

julia> [r lags]
9×2 Matrix{Float64}:
0.0          -4.0
4.14728e-17  -3.0
0.178468     -2.0
0.457473     -1.0
0.994189      0.0
0.477211      1.0
0.229061      2.0
0.105402      3.0
0.0411191     4.0

julia> r, lags = crosscorr(x,y,normalize=true,padmode=:none);

julia> [r lags]
7×2 Matrix{Float64}:
0.178468   1.0
0.457473   2.0
0.994189   3.0
0.477211   4.0
0.229061   5.0
0.105402   6.0
0.0411191  7.0

source

IceFloeTracker.deleteallbut! — Method

deleteallbut!(matched_pairs, idxs, keeper)

Delete all rows in matched_pairs except for the row with index keeper in idxs.

source

IceFloeTracker.detect_move! — Method

Workhorse function: Get all pixel coords for detected border.

source

IceFloeTracker.discriminate_ice_water — Method

discriminate_ice_water(
falsecolor_image::Matrix{RGB{Float64}},
normalized_image::Matrix{Gray{Float64}},
landmask_bitmatrix::T,
cloudmask_bitmatrix::T,
floes_threshold::Float64=Float64(100 / 255),
mask_clouds_lower::Float64=Float64(17 / 255),
mask_clouds_upper::Float64=Float64(30 / 255),
kurt_thresh_lower::Real=2,
kurt_thresh_upper::Real=8,
skew_thresh::Real=4,
st_dev_thresh_lower::Float64=Float64(84 / 255),
st_dev_thresh_upper::Float64=Float64(98.9 / 255),
clouds_ratio_threshold::Float64=0.02,
differ_threshold::Float64=0.6,
nbins::Real=155

)

Generates an image with ice floes apparent after filtering and combining previously processed versions of falsecolor and truecolor images from the same region of interest. Returns an image ready for segmentation to isolate floes.

Note: This function mutates the landmask object to avoid unnecessary memory allocation. If you need the original landmask, make a copy before passing it to this function. Example: discriminate_ice_water(falsecolor_image, normalized_image, copy(landmask_bitmatrix), cloudmask_bitmatrix)

Arguments

falsecolor_image: input image in false color reflectance
normalized_image: normalized version of true color image
landmask_bitmatrix: landmask for region of interest
cloudmask_bitmatrix: cloudmask for region of interest
floes_threshold: heuristic applied to original false color image
mask_clouds_lower: lower heuristic applied to mask out clouds
mask_clouds_upper: upper heuristic applied to mask out clouds
kurt_thresh_lower: lower heuristic used to set pixel value threshold based on kurtosis in histogram
kurt_thresh_upper: upper heuristic used to set pixel value threshold based on kurtosis in histogram
skew_thresh: heuristic used to set pixel value threshold based on skewness in histogram
st_dev_thresh_lower: lower heuristic used to set pixel value threshold based on standard deviation in histogram
st_dev_thresh_upper: upper heuristic used to set pixel value threshold based on standard deviation in histogram
clouds2_threshold: heuristic used to set pixel value threshold based on ratio of clouds
differ_threshold: heuristic used to calculate proportional intensity in histogram
nbins: number of bins during histogram build

source

IceFloeTracker.dist — Method

dist(p1, p2)

Return the distance between the points p1 and p2.

source

IceFloeTracker.filt_except_label! — Method

filt_except_label!(labeled_arr::Array{Int64, 2}, label::Int64)

In-place version of filt_except_label.

See also filt_except_label!

source

IceFloeTracker.find_ice_labels — Method

find_ice_labels(falsecolor_image, landmask; band_7_threshold, band_2_threshold, band_1_threshold, band_7_relaxed_threshold, band_1_relaxed_threshold, possible_ice_threshold)

Locate the pixels of likely ice from false color reflectance image. Returns a binary mask with ice floes contrasted from background. Default thresholds are defined in the published Ice Floe Tracker article: Remote Sensing of the Environment 234 (2019) 111406.

Arguments

falsecolor_image: corrected reflectance false color image - bands [7,2,1]
landmask: bitmatrix landmask for region of interest
band_7_threshold: threshold value used to identify ice in band 7, N0f8(RGB intensity/255)
band_2_threshold: threshold value used to identify ice in band 2, N0f8(RGB intensity/255)
band_1_threshold: threshold value used to identify ice in band 2, N0f8(RGB intensity/255)
band_7_relaxed_threshold: threshold value used to identify ice in band 7 if not found on first pass, N0f8(RGB intensity/255)
band_1_relaxed_threshold: threshold value used to identify ice in band 1 if not found on first pass, N0f8(RGB intensity/255)

source

IceFloeTracker.find_reflectance_peaks — Method

find_reflectance_peaks(reflectance_channel, possible_ice_threshold;)

Find histogram peaks in single channels of a reflectance image and return the second greatest peak. If needed, edges can be returned as the first object from build_histogram. Similarly, peak values can be returned as the second object from findmaxima.

Arguments

reflectance_channel: either band 2 or band 1 of false-color reflectance image
possible_ice_threshold: threshold value used to identify ice if not found on first or second pass

source

IceFloeTracker.fixzeroindexing! — Method

fixzeroindexing!(props::DataFrame, props_to_fix::Vector{T}) where T<:Union{Symbol,String}

Fix the zero-indexing of the props_to_fix columns in props by adding 1 to each element.

source

IceFloeTracker.fname_ext_splice — Method

fname_ext_splice(fname, ext)

Join "fname" and "ext" with '.'.

source

IceFloeTracker.fname_ext_split — Method

fname_ext_split(fname)

Split "fname.ext" into "fname" and "ext".

source

IceFloeTracker.from_to — Method

Get index in Moore neigborhood representing the direction from the from pixel coords to the to pixel coords (see definition of dir_delta below).

Clockwise Moore neighborhood.

dir_delta = [CartesianIndex(-1, 0), CartesianIndex(-1, 1), CartesianIndex(0, 1), CartesianIndex(1, 1), CartesianIndex(1, 0), CartesianIndex(1, -1), CartesianIndex(0, -1), CartesianIndex(-1,-1)]

source

IceFloeTracker.get_areas — Method

get_areas(labeled_arr::Array{T, 2})::Dict{T, Int} where T

Get the "areas" (count of pixels of a given label) of the connected components in labeled_arr.

Return a dictionary with the frequency distribution: label => countoflabel.

source

IceFloeTracker.get_max_label — Method

get_max_label(d::Dict{Int, Int})

Get the label k in dictionary d for which d[k] is maximal.

source

IceFloeTracker.getbboxcolumns — Method

getbboxcolumns(props::DataFrame)

Return the column names of the bounding box columns in props.

source

IceFloeTracker.getbestmatchdata — Method

getbestmatchdata(idx, r, props_day1, matching_floes)

Collect the data for the best match between the rth floe in props_day1 and the idxth floe in matching_floes. Return a tuple of the floe properties for day 1 and day 2 and the ratios.

source

IceFloeTracker.getcentroid — Method

getcentroid(props_day::DataFrame, r)

Get the coordinates of the rth floe in props_day.

source

IceFloeTracker.getcentroidcolumns — Method

getcentroidcolumns(props::DataFrame)

Returns the column names of the centroid columns in props.

source

IceFloeTracker.getcollisions — Method

getcollisions(matchedpairs)

Get nonunique rows in matchedpairs.

source

IceFloeTracker.getcollisionslocs — Method

getcollisionslocs(df)

Return a vector of tuples of the row and the index of the row in df that has a collision with another row in df.

source

IceFloeTracker.getfloemasks — Method

getfloemasks(props::DataFrame, floeimg::BitMatrix)

Return a vector of cropped floe masks from floeimg using the bounding box data in props.

source

IceFloeTracker.getidxmostminimumeverything — Method

getidxmostminimumeverything(ratiosdf)

Return the index of the row in ratiosdf with the most minima across its columns. If there are multiple columns with the same minimum value, return the index of the first column with the minimum value. If ratiosdf is empty, return NaN.

source

IceFloeTracker.getidxofrow — Method

getidxofrow(rw0, df)

Return the indices of the rows in df that are equal to rw0.

source

IceFloeTracker.getpropsday1day2 — Method

getpropsday1day2(properties, dayidx::Int64)

Return the floe properties for day dayidx and day dayidx+1.

source

IceFloeTracker.getsizecomparability — Method

getsizecomparability(s1, s2)

Check if the size of two floes s1 and s2 are comparable. The size is defined as the product of the floe dimensions.

Arguments

s1: size of floe 1
s2: size of floe 2

source

IceFloeTracker.grad — Method

dx, dy = grad(A::Matrix{<:Number})

Make gradient vector field for the set of points with coordinates in the rows of the matrix A with x-coordinates down column 1 and y-coordinates down column 2. Return a tuple with dx and dy in that order.

source

IceFloeTracker.grad — Method

dx, dy = grad(x::Vector{<:Number}, y::Vector{<:Number})

Make gradient vector field for the set of points with coordinates in vectors x and y. Return a tuple with dx and dy in that order.

source

IceFloeTracker.hbreak! — Method

hbreak!(img::AbstractArray{Bool})

Inplace version of hbreak. See also hbreak.

source

IceFloeTracker.hbreak — Method

hbreak(img::AbstractArray{Bool})

Remove H-connected pixels in the binary image img. See also hbreak! for an inplace version of this function.

Examples

```jldoctest; setup = :(using IceFloeTracker)

julia> h1 = trues(3,3); h1[[1 3], 2] .= false; h1 3×3 BitMatrix: 1 0 1 1 1 1 1 0 1

julia> h2 = trues(3,3); h2[2, [1 3]] .= false; h2 3×3 BitMatrix: 1 1 1 0 1 0 1 1 1

julia> hbreak!(h1); h1 # modify h1 inplace 3×3 BitMatrix: 1 0 1 1 0 1 1 0 1

julia> hbreak(h2) 3×3 BitMatrix: 1 1 1 0 0 0 1 1 1

source

IceFloeTracker.imextendedmin — Method

imextendedmin(img)

Mimics MATLAB's imextendedmin function that computes the extended-minima transform, which is the regional minima of the H-minima transform. Regional minima are connected components of pixels with a constant intensity value. This function returns a transformed bitmatrix.

Arguments

img: image object
h: suppress minima below this depth threshold
conn: neighborhood connectivity; in 2D 1 = 4-neighborhood and 2 = 8-neighborhood

source

IceFloeTracker.imsharpen — Function

imsharpen(truecolor_image, landmask_no_dilate, lambda, kappa, niters, nbins, rblocks, cblocks, clip, smoothing_param, intensity)

Sharpen truecolor_image.

Arguments

truecolor_image: input image in truecolor
landmask_no_dilate: landmask for region of interest
lambda: speed of diffusion (0–0.25)
kappa: conduction coefficient for diffusion (25–100)
niters: number of iterations of diffusion
nbins: number of bins during histogram equalization
rblocks: number of row blocks to divide input image during equalization
cblocks: number of column blocks to divide input image during equalization
clip: Thresholds for clipping histogram bins (0–1); values closer to one minimize contrast enhancement, values closer to zero maximize contrast enhancement
smoothing_param: pixel radius for gaussian blurring (1–10)
intensity: amount of sharpening to perform

source

IceFloeTracker.imsharpen_gray — Method

imsharpen_gray(imgsharpened, landmask)

Apply landmask and return Gray type image in colorview for normalization.

source

IceFloeTracker.isfloegoodmatch — Method

isfloegoodmatch(conditions, mct, area_mismatch, corr)

Return true if the floes are a good match as per the set thresholds. Return false otherwise.

Arguments

conditions: tuple of booleans for evaluating the conditions
mct: tuple of thresholds for the match correlation test
area_mismatch and corr: values returned by match_corr

source

IceFloeTracker.isincountourlist — Method

Check P is in countour list if so return the index of the contour that contains P, otherwise return false.

source

IceFloeTracker.ismember — Method

ismember(df1,df2)

Return a boolean array indicating whether each row in df1 is a member of df2.

source

IceFloeTracker.kmeans_segmentation — Method

kmeans_segmentation(gray_image, ice_labels;)

Apply k-means segmentation to a gray image to isolate a cluster group representing sea ice. Returns a binary image with ice segmented from background.

Arguments

gray_image: output image from ice-water-discrimination.jl or gray ice floe leads image in segmentation_f.jl
ice_labels: vector if pixel coordinates output from find_ice_labels.jl

source

IceFloeTracker.loadimg — Method

loadimg(; dir::String, fname::String)

Load an image from dir with filename fname into a matrix of Float64 values. Returns the loaded image.

source

IceFloeTracker.make_filename — Method

make_filename()

Makes default filename with timestamp.

source

IceFloeTracker.make_hbreak_dict — Method

make_hbreak_dict()

Build dict with the two versions of an H-connected 3x3 neighboorhood.

h1 = [1 0 1 1 1 1 1 0 1]

h2 = [1 1 1 0 1 0 1 1 1]

source

IceFloeTracker.make_lut — Method

make_lut(lutfunc::Function)

Generate lookup table (lut) for 3x3 neighborhoods according to lutfunc.

source

IceFloeTracker.make_psi_s — Method

make_psi_s(XY::Matrix{<:Number};rangeout::Bool=true,
unwrap::Bool=true)

Alternate method of make_psi_s accepting input vectors x and y as a 2-column matrix [x y] in order to facillitate workflow (output from resample_boundary).

source

IceFloeTracker.make_psi_s — Method

make_psi_s(x::Vector{<:Number},
           y::Vector{<:Number};
           rangeout::Bool=true,
           unwrap::Bool=true)::Tuple{Vector{Float64}, Vector{Float64}}

Builds the ψ-s curve defined by vectors x and y.

Returns a tuple of vectors with the phases ψ in the first component and the traversed arclength in the second component.

Following the convention in [1], the wrapped ψ-s curve has values in [0, 2π) by default; use rangeout to control this behavior.

Arguments

x: Vector of x-coordinates
y: corresponding vector of y-coordinates
rangeout: true (default) for phase values in [0, 2π); false for phase values in (-π, π].
unwrap: set to true to get "unwrapped" phases (default).

Reference

[1] McConnell, Ross, et al. "psi-s correlation and dynamic time warping: two methods for tracking ice floes in SAR images." IEEE Transactions on Geoscience and Remote sensing 29.6 (1991): 1004-1012.

Example

The example below builds a cardioid and obtains its ψ-s curve.

julia> t = range(0,2pi,201);

julia> x = @. cos(t)*(1-cos(t));

julia> y = @. sin(t)*(1-cos(t));

julia> plot(x,y) # visualize the cardioid

julia> psi, s = make_psi_s(x,y);

julia> [s psi] # inspect psi-s data
200×2 Matrix{Float64}:
 0.00049344  0.0314159
 0.0019736   0.0733034
 0.00444011  0.11938
 0.00789238  0.166055
 0.0123296   0.212929
 0.0177505   0.259894
 0.024154    0.306907
 0.0315383   0.35395
 0.0399017   0.401012
 0.0492421   0.448087
 ⋮
 7.96772     9.02377
 7.97511     9.07083
 7.98151     9.11787
 7.98693     9.16488
 7.99137     9.21185
 7.99482     9.25872
 7.99729     9.3054
 7.99877     9.35147
 7.99926     9.39336

 julia> plot(s, psi) # inspect psi-s curve -- should be a straight line from (0, 0) to (8, 3π)

source

IceFloeTracker.makecontourstartatP — Method

Make contour start at point P by permuting the elements in contour.

source

IceFloeTracker.makeemptydffrom — Method

makeemptydffrom(df::DataFrame)

Return an object with an empty dataframe with the same column names as df and an empty dataframe with column names area, majoraxis, minoraxis, convex_area, area_mismatch, and corr for similarity ratios.

source

IceFloeTracker.makeemptyratiosdf — Method

makeemptyratiosdf()

Return an empty dataframe with column names area, majoraxis, minoraxis, convex_area, area_mismatch, and corr for similarity ratios.

source

IceFloeTracker.matchcorr — Method

matchcorr(
f1::T,
f2::T,
Δt::F,
mxrot::S=10,
psi::F=0.95,
sz::S=16,
comp::F=0.25,
mm::F=0.22
)
where {T<:AbstractArray{Bool,2},S<:Int64,F<:Float64}

Compute the mismatch mm and psi-s-correlation c for floes with masks f1 and f2.

The criteria for floes to be considered equivalent is as follows: - c greater than mm - _mm is less than mm

A pair of NaN is returned for cases for which one of their mask dimension is too small or their sizes are not comparable.

Arguments

f1: mask of floe 1
f2: mask of floe 2
Δt: time difference between floes
mxrot: maximum rotation (in degrees) allowed between floesn (default: 10)
psi: psi-s-correlation threshold (default: 0.95)
sz: size threshold (default: 16)
comp: size comparability threshold (default: 0.25)
mm: mismatch threshold (default: 0.22)

source

IceFloeTracker.mean — Method

mean(x,y)

Compute the mean of x and y.

source

IceFloeTracker.mismatch — Function

mismatch(fixed::AbstractArray,
              moving::AbstractArray,
              mxshift::Tuple{Int64, Int64}=(10,10),
              mxrot::Float64=pi/4;
              kwargs...
              )

Estimate a rigid transformation (translation + rotation) that minimizes the 'mismatch' of aligning moving with fixed using the QuadDIRECT algorithm.

Returns a pair with the mismatch score mm and the associated registration angle rot.

Arguments

fixed,moving: images to align via a rigid transformation
mxshift: maximum allowed translation in units of array indices (default set to (10,10))
mxrot: maximum allowed rotation in radians (default set to π/4)
thresh: minimum sum-of-squared-intensity overlap between the images (default is 10% of the sum-of-squared-intensity of fixed)
kwargs: other arguments such as tol, ftol, and fvalue (see QuadDIRECT.analyze for details)

```

source

IceFloeTracker.modenan — Method

modenan(x::AbstractVector{<:Float64})

Return the mode of x or NaN if x is empty.

source

IceFloeTracker.move — Method

move from current pixel to the next in given direction

source

IceFloeTracker.norm — Method

norm(v)

Get the euclidean norm of the vector v.

source

IceFloeTracker.normalize_image — Method

normalize_image(image_sharpened, image_sharpened_gray, landmask, struct_elem;)

Adjusts sharpened land-masked image to highlight ice floe features.

Does reconstruction and landmasking to image_sharpened.

Arguments

image_sharpened: sharpened image (output of imsharpen)
image_sharpened_gray: grayscale, landmasked sharpened image (output of imsharpen_gray(image_sharpened))
landmask: landmask for region of interest
struct_elem: structuring element for dilation

source

IceFloeTracker.normalizeangle — Function

normalizeangle(revised,t=180)

Normalize angle to be between -180 and 180 degrees.

source

IceFloeTracker.padnhood — Method

padnhood(img, I, nhood)

Pad the matrix img[nhood] with zeros according to the position of I within the edgesimg.

Returns img[nhood] if I is not an edge index.

source

IceFloeTracker.pairfloes — Method

pairfloes(
segmented_imgs::Vector{BitMatrix},
props::Vector{DataFrame},
passtimes::Vector{DateTime},
latlonrefimage::AbstractString,
condition_thresholds,
mc_thresholds,

)

Pair floes in props[k] to floes in props[k+1] for k=1:length(props)-1.

The main steps of the algorithm are as follows:

Crop floes from segmented_imgs using bounding box data in props. Floes in the edges are removed.
For each floekr in props[k], compare to floek+1s in props[k+1] by computing similarity ratios, set of conditions, and drift distance dist. If the conditions are met, compute the area mismatch mm and psi-s correlation c for this pair of floes. Pair these two floes if mm and c satisfy the thresholds in mc_thresholds.
If there are collisions (i.e. floe s in props[k+1] is paired to more than one floe in props[k]), then the floe in props[k] with the best match is paired to floe s in props[k+1].
Drop paired floes from props[k] and props[k+1] and repeat steps 2 and 3 until there are no more floes to match in props[k].
Repeat steps 2-4 for k=2:length(props)-1.

Arguments

segmented_imgs: array of images with segmented floes
props: array of dataframes containing floe properties
passtimes: array of DateTime objects containing the time of the image in which the floes were captured
latlonrefimage: path to geotiff reference image for getting latitude and longitude of floe centroids
condition_thresholds: 3-tuple of thresholds (each a named tuple) for deciding whether to match floe i from day k to floe j from day k+1
mc_thresholds: thresholds for area mismatch and psi-s shape correlation

Returns a dataframe containing the following columns:

ID: unique ID for each floe pairing.
passtime: time of the image in which the floes were captured.
area: area of the floe in sq. kilometers
convex_area: area of the convex hull of the floe in sq. kilometers
major_axis_length: length of the major axis of the floe in kilometers
minor_axis_length: length of the minor axis of the floe in kilometers
orientation: angle between the major axis and the x-axis in radians
perimeter: perimeter of the floe in kilometers
latitude: latitude of the floe centroid
longitude: longitude of the floe centroid
x: x-coordinate of the floe centroid
y: y-coordinate of the floe centroid
area_mismatch: area mismatch between the two floes in rowi and rowi+1 after registration
corr: psi-s shape correlation between the two floes in rowi and rowi+1

source

IceFloeTracker.regionprops — Function

regionprops(label_img, ; properties, connectivity)

A wrapper of the regionprops function from the skimage python library.

See its full documentation at https://scikit-image.org/docs/stable/api/skimage.measure.html#skimage.measure.regionprops.

Arguments

label_img: Image with the labeled objects of interest
intensity_img: (Optional) Used for generating extra_properties, integer/float array from which (presumably) label_img was generated
extra_properties: (Optional) not yet implemented. It will be set to nothing

Index

IceFloeTracker.MatchedPairs
IceFloeTracker.MatchedPairs
IceFloeTracker.Tracked
Base.isequal
IceFloeTracker._adjust_histogram
IceFloeTracker._bin9todec
IceFloeTracker._branch_filter
IceFloeTracker._operator_lut
IceFloeTracker.absdiffmeanratio
IceFloeTracker.add_padding
IceFloeTracker.add_passtimes!
IceFloeTracker.addfloemasks!
IceFloeTracker.addlatlon!
IceFloeTracker.addmatch!
IceFloeTracker.appendrows!
IceFloeTracker.apply_cloudmask
IceFloeTracker.apply_landmask
IceFloeTracker.atan2
IceFloeTracker.binarize_landmask
IceFloeTracker.branch
IceFloeTracker.branch_candidates_func
IceFloeTracker.bridge
IceFloeTracker.bwareamaxfilt
IceFloeTracker.bwareamaxfilt!
IceFloeTracker.bwdist
IceFloeTracker.bwperim
IceFloeTracker.bwtraceboundary
IceFloeTracker.callmatchcorr
IceFloeTracker.check_fname
IceFloeTracker.clockwise
IceFloeTracker.compute_ratios
IceFloeTracker.compute_ratios_conditions
IceFloeTracker.connected_background_count
IceFloeTracker.convertcentroid!
IceFloeTracker.converttounits!
IceFloeTracker.corr
IceFloeTracker.corr
IceFloeTracker.counterclockwise
IceFloeTracker.create_cloudmask
IceFloeTracker.create_landmask
IceFloeTracker.cropfloe
IceFloeTracker.crosscorr
IceFloeTracker.deleteallbut!
IceFloeTracker.detect_move!
IceFloeTracker.discriminate_ice_water
IceFloeTracker.dist
IceFloeTracker.filt_except_label
IceFloeTracker.filt_except_label!
IceFloeTracker.find_ice_labels
IceFloeTracker.find_reflectance_peaks
IceFloeTracker.fixzeroindexing!
IceFloeTracker.fname_ext_splice
IceFloeTracker.fname_ext_split
IceFloeTracker.from_to
IceFloeTracker.get_areas
IceFloeTracker.get_max_label
IceFloeTracker.getbboxcolumns
IceFloeTracker.getbestmatchdata
IceFloeTracker.getcentroid
IceFloeTracker.getcentroidcolumns
IceFloeTracker.getcollisions
IceFloeTracker.getcollisionslocs
IceFloeTracker.getfloemasks
IceFloeTracker.getidxmostminimumeverything
IceFloeTracker.getidxofrow
IceFloeTracker.getpropsday1day2
IceFloeTracker.getsizecomparability
IceFloeTracker.grad
IceFloeTracker.grad
IceFloeTracker.hbreak
IceFloeTracker.hbreak!
IceFloeTracker.imextendedmin
IceFloeTracker.imsharpen
IceFloeTracker.imsharpen_gray
IceFloeTracker.isfloegoodmatch
IceFloeTracker.isincountourlist
IceFloeTracker.ismember
IceFloeTracker.kmeans_segmentation
IceFloeTracker.loadimg
IceFloeTracker.make_filename
IceFloeTracker.make_hbreak_dict
IceFloeTracker.make_lut
IceFloeTracker.make_psi_s
IceFloeTracker.make_psi_s
IceFloeTracker.makecontourstartatP
IceFloeTracker.makeemptydffrom
IceFloeTracker.makeemptyratiosdf
IceFloeTracker.matchcorr
IceFloeTracker.mean
IceFloeTracker.mismatch
IceFloeTracker.modenan
IceFloeTracker.move
IceFloeTracker.norm
IceFloeTracker.normalize_image
IceFloeTracker.normalizeangle
IceFloeTracker.padnhood
IceFloeTracker.pairfloes
IceFloeTracker.regionprops
IceFloeTracker.regionprops_table
IceFloeTracker.remove_padding
IceFloeTracker.renamecols!
IceFloeTracker.resample_boundary
IceFloeTracker.roundtoint!
IceFloeTracker.segmentation_A
IceFloeTracker.segmentation_B
IceFloeTracker.segmentation_F
IceFloeTracker.segmented_ice_cloudmasking
IceFloeTracker.sort!
IceFloeTracker.sort_floes_by_area!
IceFloeTracker.timestamp
IceFloeTracker.trackercond1
IceFloeTracker.trackercond2
IceFloeTracker.trackercond3
IceFloeTracker.update!
IceFloeTracker.watershed_ice_floes
IceFloeTracker.watershed_product
IceFloeTracker.@persist