IceFloeTracker
Documentation for IceFloeTracker.jl package.
Functions
Base.isequal
— Methodisequal(matchedpairs1::MatchedPairs, matchedpairs2::MatchedPairs)
Return true
if matchedpairs1
and matchedpairs2
are equal, false
otherwise.
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
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
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
.
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
.
IceFloeTracker.absdiffmeanratio
— Methodabsdiffmeanratio(x, y)
Calculate the absolute difference between x
and y
divided by the mean of x
and y
.
IceFloeTracker.add_padding
— Methodadd_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 asPad
orFill
) representing the extrapolation style. See the relevant documentation for details.
See also remove_padding
IceFloeTracker.add_passtimes!
— Methodadd_passtimes!(props, passtimes)
Add a column passtime
to each DataFrame in props
containing the time of the image in which the floes were captured.
Arguments
props
: array of DataFrames containing floe properties.passtimes
: array ofDateTime
objects containing the time of the image in which the floes were captured.
IceFloeTracker.addfloemasks!
— Methodaddfloearrays(props::DataFrame, floeimg::BitMatrix)
Add a column to props
called floearray
containing the cropped floe masks from floeimg
.
IceFloeTracker.addlatlon!
— Methodaddlatlon(pairedfloesdf::DataFrame, refimage::AbstractString)
Add columns latitude
, longitude
, and pixel coordinates x
, y
to pairedfloesdf
.
Arguments
pairedfloesdf
: dataframe containing floe tracking data.refimage
: path to reference image.
IceFloeTracker.addmatch!
— Methodaddmatch!(matched_pairs, newmatch)
Add newmatch
to matched_pairs
.
IceFloeTracker.appendrows!
— Methodappendrows!(df::MatchingProps, props::T, ratios, idx::Int64, dist::Float64) where {T<:DataFrameRow}
Append a row to df.props
and df.ratios
with the values of props
and ratios
respectively.
IceFloeTracker.apply_cloudmask
— Methodapply_cloudmask(ref_image, cloudmask)
Zero out pixels containing clouds where clouds and ice are not discernable. Arguments should be of the same size.
Arguments
ref_image
: reference image, e.g. corrected reflectance false color image bands [7,2,1] or grayscalecloudmask
: binary cloudmask with clouds = 0, else = 1
IceFloeTracker.apply_landmask
— Methodapply_landmask(input_image, landmask_binary)
Zero out pixels in land and soft ice regions on truecolor image, return RGB image with zero for all three channels on land/soft ice.
Arguments
input_image
: truecolor RGB imagelandmask_binary
: binary landmask with 1=land, 0=water/ice
IceFloeTracker.atan2
— Methodatan2(y,x)
Wrapper of Base.atan
that returns the angle of vector (x,y) in the range [0, 2π).
IceFloeTracker.binarize_landmask
— Methodbinarize_landmask(landmask_image)
Convert a 3-channel RGB land mask image to a 1-channel binary matrix; land = 0, water/ice = 1.
Arguments
landmask_image
: RGB land mask image fromfetchdata
IceFloeTracker.branch
— Methodbranch(img::AbstractArray{Bool})
Find branch points in skeletonized image img
according to Definition 3 of [1].
[1] Arcelli, Carlo, and Gabriella Sanniti di Baja. "Skeletons of planar patterns." Machine Intelligence and Pattern Recognition. Vol. 19. North-Holland, 1996. 99-143.
IceFloeTracker.branch_candidates_func
— Methodbranch_candidates_func(nhood)
Filter nhood
as candidate for branch point.
To be passed to the make_lut
function.
IceFloeTracker.bridge
— Methodbridge(bw)
Set 0-valued pixels to 1 if they have two nonzero neighbors that are not connected. Note the following exceptions:
0 0 0 0 0 0 1 0 1 becomes 1 1 1 0 0 0 0 0 0
1 0 1 1 1 1 0 0 0 becomes 0 0 0 0 0 0 0 0 0
The same applies to all their corresponding rotations.
Examples
julia> bw = [0 0 0; 0 0 0; 1 0 1]
3×3 Matrix{Int64}:
0 0 0
0 0 0
1 0 1
julia> bridge(bw)
3×3 BitMatrix:
0 0 0
0 0 0
1 1 1
julia> bw = [1 0 0; 1 0 1; 0 0 1]
3×3 Matrix{Int64}:
1 0 0
1 0 1
0 0 1
julia> bridge(bw)
3×3 BitMatrix:
1 1 0
1 1 1
0 1 1
julia> bw = [1 0 1; 0 0 0; 1 0 1]
3×3 Matrix{Int64}:
1 0 1
0 0 0
1 0 1
julia> bridge(bw)
3×3 BitMatrix:
1 1 1
1 1 1
1 1 1
IceFloeTracker.bwareamaxfilt
— Functionbwareamaxfilt(bwimg::AbstractArray{Bool}, conn)
Filter the smaller (by area) connected components in bwimg
keeping the (assumed unique) largest.
Uses 8-pixel connectivity by default (conn=8
). Use conn=4
for 4-pixel connectivity.
IceFloeTracker.bwareamaxfilt!
— FunctionIceFloeTracker.bwdist
— Methodbwdist(bwimg)
Distance transform for binary image bwdist
.
IceFloeTracker.bwperim
— Methodbwperim(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
IceFloeTracker.bwtraceboundary
— Methodbwtraceboundary(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
: iftrue
(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)
IceFloeTracker.callmatchcorr
— Methodcallmatchcorr(conditions)
Condition to decide whether match_corr should be called.
IceFloeTracker.check_fname
— Functioncheck_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.
IceFloeTracker.clockwise
— MethodMake a clockwise turn from the dir
direction
IceFloeTracker.compute_ratios
— Methodcompute_ratios((props_day1, r), (props_day2,s))
Compute the ratios of the floe properties between the r
th floe in props_day1
and the s
th floe in props_day2
. Return a tuple of the ratios.
Arguments
props_day1
: floe properties for day 1r
: index of floe inprops_day1
props_day2
: floe properties for day 2s
: index of floe inprops_day2
IceFloeTracker.compute_ratios_conditions
— Methodcompute_ratios_conditions((props_day1, r), (props_day2, s), delta_time, t)
Compute the conditions for a match between the r
th floe in props_day1
and the s
th floe in props_day2
. Return a tuple of the conditions.
Arguments
props_day1
: floe properties for day 1r
: index of floe inprops_day1
props_day2
: floe properties for day 2s
: index of floe inprops_day2
delta_time
: time elapsed from image day 1 to image day 2t
: tuple of thresholds for elapsed time and distance. Seepair_floes
for details.
IceFloeTracker.connected_background_count
— Methodconnected_background_count(nhood)
Second lut generator for neighbor transform with diamond strel (4-neighborhood).
To be passed to the make_lut
function.
IceFloeTracker.convertcentroid!
— Methodconvertcentroid!(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.
IceFloeTracker.converttounits!
— Methodconverttounits!(propdf, latlondata, colstodrop)
Convert the floe properties from pixels to kilometers and square kilometers where appropiate. Also drop the columns specified in colstodrop
.
IceFloeTracker.corr
— Methodcorr(f1,f2)
Return the correlation between the psi-s curves p1
and p2
.
IceFloeTracker.corr
— Methodcorr(f1,f2)
Return the normalized cross-correlation between the psi-s curves p1
and p2
.
IceFloeTracker.counterclockwise
— MethodMake a counterclockwise turn from the dir
direction
IceFloeTracker.create_cloudmask
— Methodcreate_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 2ratio_upper
: threshold value used to set upper ratio of cloud-ice in bands 7 and 2
IceFloeTracker.create_landmask
— Methodcreate_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 fromfetchdata
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)
IceFloeTracker.cropfloe
— Methodcropfloe(floesimg, props, i)
Crops the floe delimited by the bounding box data in props
at index i
from the floe image floesimg
.
IceFloeTracker.crosscorr
— Methodr, 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
IceFloeTracker.deleteallbut!
— Methoddeleteallbut!(matched_pairs, idxs, keeper)
Delete all rows in matched_pairs
except for the row with index keeper
in idxs
.
IceFloeTracker.detect_move!
— MethodWorkhorse function: Get all pixel coords for detected border.
IceFloeTracker.discriminate_ice_water
— Methoddiscriminate_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 reflectancenormalized_image
: normalized version of true color imagelandmask_bitmatrix
: landmask for region of interestcloudmask_bitmatrix
: cloudmask for region of interestfloes_threshold
: heuristic applied to original false color imagemask_clouds_lower
: lower heuristic applied to mask out cloudsmask_clouds_upper
: upper heuristic applied to mask out cloudskurt_thresh_lower
: lower heuristic used to set pixel value threshold based on kurtosis in histogramkurt_thresh_upper
: upper heuristic used to set pixel value threshold based on kurtosis in histogramskew_thresh
: heuristic used to set pixel value threshold based on skewness in histogramst_dev_thresh_lower
: lower heuristic used to set pixel value threshold based on standard deviation in histogramst_dev_thresh_upper
: upper heuristic used to set pixel value threshold based on standard deviation in histogramclouds2_threshold
: heuristic used to set pixel value threshold based on ratio of cloudsdiffer_threshold
: heuristic used to calculate proportional intensity in histogramnbins
: number of bins during histogram build
IceFloeTracker.dist
— Methoddist(p1, p2)
Return the distance between the points p1
and p2
.
IceFloeTracker.filt_except_label!
— Methodfilt_except_label!(labeled_arr::Array{Int64, 2}, label::Int64)
In-place version of filt_except_label
.
See also filt_except_label
IceFloeTracker.filt_except_label
— Methodfilt_except_label(labeled_arr::Array{Int64, 2}, label::Int64)
Make 0 all values in labeled_arr
that are not equal to label
.
See also filt_except_label!
IceFloeTracker.find_ice_labels
— Methodfind_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 interestband_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)
IceFloeTracker.find_reflectance_peaks
— Methodfind_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 imagepossible_ice_threshold
: threshold value used to identify ice if not found on first or second pass
IceFloeTracker.fixzeroindexing!
— Methodfixzeroindexing!(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.
IceFloeTracker.fname_ext_splice
— Methodfname_ext_splice(fname, ext)
Join "fname"
and "ext"
with '.'
.
IceFloeTracker.fname_ext_split
— Methodfname_ext_split(fname)
Split "fname.ext"
into "fname"
and "ext"
.
IceFloeTracker.from_to
— MethodGet 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)]
IceFloeTracker.get_areas
— Methodget_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.
IceFloeTracker.get_max_label
— Methodget_max_label(d::Dict{Int, Int})
Get the label k
in dictionary d
for which d[k] is maximal.
IceFloeTracker.getbboxcolumns
— Methodgetbboxcolumns(props::DataFrame)
Return the column names of the bounding box columns in props
.
IceFloeTracker.getbestmatchdata
— Methodgetbestmatchdata(idx, r, props_day1, matching_floes)
Collect the data for the best match between the r
th floe in props_day1
and the idx
th floe in matching_floes
. Return a tuple of the floe properties for day 1 and day 2 and the ratios.
IceFloeTracker.getcentroid
— Methodgetcentroid(props_day::DataFrame, r)
Get the coordinates of the r
th floe in props_day
.
IceFloeTracker.getcentroidcolumns
— Methodgetcentroidcolumns(props::DataFrame)
Returns the column names of the centroid columns in props
.
IceFloeTracker.getcollisions
— Methodgetcollisions(matchedpairs)
Get nonunique rows in matchedpairs
.
IceFloeTracker.getcollisionslocs
— Methodgetcollisionslocs(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
.
IceFloeTracker.getfloemasks
— Methodgetfloemasks(props::DataFrame, floeimg::BitMatrix)
Return a vector of cropped floe masks from floeimg
using the bounding box data in props
.
IceFloeTracker.getidxmostminimumeverything
— Methodgetidxmostminimumeverything(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
.
IceFloeTracker.getidxofrow
— Methodgetidxofrow(rw0, df)
Return the indices of the rows in df
that are equal to rw0
.
IceFloeTracker.getpropsday1day2
— Methodgetpropsday1day2(properties, dayidx::Int64)
Return the floe properties for day dayidx
and day dayidx+1
.
IceFloeTracker.getsizecomparability
— Methodgetsizecomparability(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 1s2
: size of floe 2
IceFloeTracker.grad
— Methoddx, 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.
IceFloeTracker.grad
— Methoddx, 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.
IceFloeTracker.hbreak!
— Methodhbreak!(img::AbstractArray{Bool})
Inplace version of hbreak
. See also hbreak
.
IceFloeTracker.hbreak
— Methodhbreak(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
IceFloeTracker.imextendedmin
— Methodimextendedmin(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 objecth
: suppress minima below this depth thresholdconn
: neighborhood connectivity; in 2D 1 = 4-neighborhood and 2 = 8-neighborhood
IceFloeTracker.imsharpen
— Functionimsharpen(truecolor_image, landmask_no_dilate, lambda, kappa, niters, nbins, rblocks, cblocks, clip, smoothing_param, intensity)
Sharpen truecolor_image
.
Arguments
truecolor_image
: input image in truecolorlandmask_no_dilate
: landmask for region of interestlambda
: speed of diffusion (0–0.25)kappa
: conduction coefficient for diffusion (25–100)niters
: number of iterations of diffusionnbins
: number of bins during histogram equalizationrblocks
: number of row blocks to divide input image during equalizationcblocks
: number of column blocks to divide input image during equalizationclip
: Thresholds for clipping histogram bins (0–1); values closer to one minimize contrast enhancement, values closer to zero maximize contrast enhancementsmoothing_param
: pixel radius for gaussian blurring (1–10)intensity
: amount of sharpening to perform
IceFloeTracker.imsharpen_gray
— Methodimsharpen_gray(imgsharpened, landmask)
Apply landmask and return Gray type image in colorview for normalization.
IceFloeTracker.isfloegoodmatch
— Methodisfloegoodmatch(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 conditionsmct
: tuple of thresholds for the match correlation testarea_mismatch
andcorr
: values returned bymatch_corr
IceFloeTracker.isincountourlist
— MethodCheck P
is in countour list if so return the index of the contour that contains P
, otherwise return false.
IceFloeTracker.ismember
— Methodismember(df1,df2)
Return a boolean array indicating whether each row in df1
is a member of df2
.
IceFloeTracker.kmeans_segmentation
— Methodkmeans_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 fromice-water-discrimination.jl
or gray ice floe leads image insegmentation_f.jl
ice_labels
: vector if pixel coordinates output fromfind_ice_labels.jl
IceFloeTracker.loadimg
— Methodloadimg(; dir::String, fname::String)
Load an image from dir
with filename fname
into a matrix of Float64
values. Returns the loaded image.
IceFloeTracker.make_filename
— Methodmake_filename()
Makes default filename with timestamp.
IceFloeTracker.make_hbreak_dict
— Methodmake_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]
IceFloeTracker.make_lut
— Methodmake_lut(lutfunc::Function)
Generate lookup table (lut) for 3x3 neighborhoods according to lutfunc
.
IceFloeTracker.make_psi_s
— Methodmake_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
).
IceFloeTracker.make_psi_s
— Methodmake_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.
See also bwtraceboundary
, resample_boundary
Arguments
x
: Vector of x-coordinatesy
: corresponding vector of y-coordinatesrangeout
:true
(default) for phase values in [0, 2π);false
for phase values in (-π, π].unwrap
: set totrue
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π)
IceFloeTracker.makecontourstartatP
— MethodMake contour start at point P by permuting the elements in contour.
IceFloeTracker.makeemptydffrom
— Methodmakeemptydffrom(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.
IceFloeTracker.makeemptyratiosdf
— Methodmakeemptyratiosdf()
Return an empty dataframe with column names area
, majoraxis
, minoraxis
, convex_area
, area_mismatch
, and corr
for similarity ratios.
IceFloeTracker.matchcorr
— Methodmatchcorr(
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 1f2
: mask of floe 2Δt
: time difference between floesmxrot
: 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)
IceFloeTracker.mean
— Methodmean(x,y)
Compute the mean of x
and y
.
IceFloeTracker.mismatch
— Functionmismatch(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 transformationmxshift
: 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 offixed
)kwargs
: other arguments such astol
,ftol
, andfvalue
(see QuadDIRECT.analyze for details)
```
IceFloeTracker.modenan
— Methodmodenan(x::AbstractVector{<:Float64})
Return the mode of x
or NaN
if x
is empty.
IceFloeTracker.move
— Methodmove from current pixel to the next in given direction
IceFloeTracker.norm
— Methodnorm(v)
Get the euclidean norm of the vector v
.
IceFloeTracker.normalize_image
— Methodnormalize_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 ofimsharpen
)image_sharpened_gray
: grayscale, landmasked sharpened image (output ofimsharpen_gray(image_sharpened)
)landmask
: landmask for region of intereststruct_elem
: structuring element for dilation
IceFloeTracker.normalizeangle
— Functionnormalizeangle(revised,t=180)
Normalize angle to be between -180 and 180 degrees.
IceFloeTracker.padnhood
— Methodpadnhood(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.
IceFloeTracker.pairfloes
— Methodpairfloes(
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 inprops
. Floes in the edges are removed. - For each floekr in
props[k]
, compare to floek+1s inprops[k+1]
by computing similarity ratios, set ofconditions
, and drift distancedist
. If the conditions are met, compute the area mismatchmm
and psi-s correlationc
for this pair of floes. Pair these two floes ifmm
andc
satisfy the thresholds inmc_thresholds
. - If there are collisions (i.e. floe
s
inprops[k+1]
is paired to more than one floe inprops[k]
), then the floe inprops[k]
with the best match is paired to floes
inprops[k+1]
. - Drop paired floes from
props[k]
andprops[k+1]
and repeat steps 2 and 3 until there are no more floes to match inprops[k]
. - Repeat steps 2-4 for
k=2:length(props)-1
.
Arguments
segmented_imgs
: array of images with segmented floesprops
: array of dataframes containing floe propertiespasstimes
: array ofDateTime
objects containing the time of the image in which the floes were capturedlatlonrefimage
: path to geotiff reference image for getting latitude and longitude of floe centroidscondition_thresholds
: 3-tuple of thresholds (each a named tuple) for deciding whether to match floei
from dayk
to floe j from dayk+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. kilometersconvex_area
: area of the convex hull of the floe in sq. kilometersmajor_axis_length
: length of the major axis of the floe in kilometersminor_axis_length
: length of the minor axis of the floe in kilometersorientation
: angle between the major axis and the x-axis in radiansperimeter
: perimeter of the floe in kilometerslatitude
: latitude of the floe centroidlongitude
: longitude of the floe centroidx
: x-coordinate of the floe centroidy
: y-coordinate of the floe centroidarea_mismatch
: area mismatch between the two floes in rowi and rowi+1 after registrationcorr
: psi-s shape correlation between the two floes in rowi and rowi+1
IceFloeTracker.regionprops
— Functionregionprops(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 interestintensity_img
: (Optional) Used for generatingextra_properties
, integer/float array from which (presumably)label_img
was generatedextra_properties
: (Optional) not yet implemented. It will be set tonothing
See also regionprops_table
Examples
julia> Random.seed!(123);
julia> bw_img = rand([0, 1], 5, 10)
5×10 Matrix{Int64}:
1 0 1 0 0 0 0 0 0 1
1 0 1 1 1 0 0 0 1 1
1 1 0 1 1 0 1 0 0 1
0 1 0 1 0 0 0 0 1 0
1 0 0 0 0 1 0 1 0 1
julia> label_img = Images.label_components(bw_img, trues(3,3))
5×10 Matrix{Int64}:
1 0 1 0 0 0 0 0 0 4
1 0 1 1 1 0 0 0 4 4
1 1 0 1 1 0 3 0 0 4
0 1 0 1 0 0 0 0 4 0
1 0 0 0 0 2 0 4 0 4
julia> regions = regionprops(label_img, bw_img);
julia> for region in regions
println(region.area," ", region.perimeter)
end
13 11.621320343559642
1 0.0
1 0.0
7 4.621320343559642
IceFloeTracker.regionprops_table
— Functionregionprops_table(label_img, intensity_img; properties, connectivity, extra_properties)
A wrapper of the regionprops_table
function from the skimage python library.
See its full documentation at https://scikit-image.org/docs/stable/api/skimage.measure.html#regionprops-table.
Arguments
label_img
: Image with the labeled objects of interestintensity_img
: (Optional) Used for generatingextra_properties
, integer/float array from which (presumably)label_img
was generatedproperties
: List (Vector
orTuple
) of properties to be generated for each connected component inlabel_img
extra_properties
: (Optional) not yet implemented. It will be set tonothing
Notes
- Zero indexing has been corrected for the
bbox
andcentroid
properties bbox
data (max_col
andmax_row
) are inclusivecentroid
data are rounded to the nearest integer
See also regionprops
Examples
julia> using IceFloeTracker, Random
julia> Random.seed!(123);
julia> bw_img = rand([0, 1], 5, 10)
5×10 Matrix{Int64}:
1 0 1 0 0 0 0 0 0 1
1 0 1 1 1 0 0 0 1 1
1 1 0 1 1 0 1 0 0 1
0 1 0 1 0 0 0 0 1 0
1 0 0 0 0 1 0 1 0 1
julia> label_img = IceFloeTracker.label_components(bw_img, trues(3,3))
5×10 Matrix{Int64}:
1 0 1 0 0 0 0 0 0 4
1 0 1 1 1 0 0 0 4 4
1 1 0 1 1 0 3 0 0 4
0 1 0 1 0 0 0 0 4 0
1 0 0 0 0 2 0 4 0 4
julia> properties = ["area", "perimeter"]
2-element Vector{String}:
"area"
"perimeter"
julia> IceFloeTracker.regionprops_table(label_img, bw_img, properties = properties)
4×2 DataFrame
Row │ area perimeter
│ Int32 Float64
─────┼──────────────────
1 │ 13 11.6213
2 │ 1 0.0
3 │ 1 0.0
4 │ 7 4.62132
IceFloeTracker.remove_padding
— Methodremove_padding(paddedimg, border_spec)
Removes padding from the boundary of padded image paddedimg
according to the border specification border_spec
type. Returns the cropped image.
Arguments
paddedimg
: Pre-padded image.border_spec
: Type representing the style of padding (such asPad
orFill
) with whichpaddedimg
is assumend to be pre-padded. Example:Pad((1,2), (3,4))
specifies 1 row on the top, 2 columns on the left, 3 rows on the bottom, and 4 columns on the right boundary.
See also add_padding
IceFloeTracker.renamecols!
— Methodrenamecols!(props::DataFrame, oldnames::Vector{T}, newnames::Vector{T}) where T<:Union{Symbol,String}
Rename the oldnames
columns in props
to newnames
.
IceFloeTracker.resample_boundary
— Functionresample_boundary(bd_points::Vector{<:CartesianIndex}, reduc_factor::Int64=2, bd::String="natural")
Get a uniform set of resampled boundary points from bd_points
using cubic splines with specified boundary conditions
The resampled set of points is obtained using parametric interpolation of the points in bd_points
. It is assumed that the separation between a pair of adjacent points is 1.
Arguments
bd_points
: Sequetial set of boundary points for the object of interestreduc_factor
: Factor by which to reduce the number of points inbd_points
(2 by default)
-bd
: Boundary condition, either 'natural' (default) or 'periodic'
See also bwtraceboundary
Example
```jldoctest; setup = :(using IceFloeTracker) 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 = 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)
julia> resample_boundary(boundary[3]) 4×2 Matrix{Float64}: 10.0 13.0 12.0357 13.5859 10.5859 15.0357 10.0 13.0
IceFloeTracker.roundtoint!
— Methodroundtoint!(props::DataFrame, colnames::Vector{T}) where T<:Union{Symbol,String}
Round the colnames
columns in props
to Int
.
IceFloeTracker.segmentation_A
— Methodsegmentation_A(segmented_ice_cloudmasked; min_opening_area)
Apply k-means segmentation to a gray image to isolate a cluster group representing sea ice. Returns an image segmented and processed as well as an intermediate files needed for downstream functions.
Arguments
segmented_ice_cloudmask
: bitmatrix with open water/clouds = 0, ice = 1, output fromsegmented_ice_cloudmasking()
min_opening_area
: minimum size of pixels to use during morphological openingfill_range
: range of values dictating the size of holes to fill
IceFloeTracker.segmentation_B
— Functionsegmentation_B(sharpened_image, cloudmask, segmented_a_ice_mask, struct_elem; fill_range, isolation_threshold, alpha_level, adjusted_ice_threshold)
Performs image processing and morphological filtering with intermediate files from normalization.jl and segmentation_A to further isolate ice floes, returning a mask of potential ice.
Arguments
sharpened_image
: non-cloudmasked but sharpened image, output fromnormalization.jl
cloudmask
: bitmatrix cloudmask for region of interestsegmented_a_ice_mask
: binary cloudmasked ice mask fromsegmentation_a_direct.jl
struct_elem
: structuring element for dilationfill_range
: range of values dictating the size of holes to fillisolation_threshold
: threshold used to isolated pixels fromsharpened_image
; between 0-1alpha_level
: alpha threshold used to adjust contrastgamma_factor
: amount of gamma adjustmentadjusted_ice_threshold
: threshold used to set ice equal to one after gamma adjustment
IceFloeTracker.segmentation_F
— Methodsegmentation_F(
segmentation_B_not_ice_mask::Matrix{Gray{Float64}},
segmentation_B_ice_intersect::BitMatrix,
segmentation_B_watershed_intersect::BitMatrix,
ice_labels::Vector{Int64},
cloudmask::BitMatrix,
landmask::BitMatrix;
min_area_opening::Int64=20
)
Cleans up past segmentation images with morphological operations, and applies the results of prior watershed segmentation, returning the final cleaned image for tracking with ice floes segmented and isolated.
Arguments
segmentation_B_not_ice_mask
: gray image output fromsegmentation_b.jl
segmentation_B_ice_intersect
: binary mask output fromsegmentation_b.jl
segmentation_B_watershed_intersect
: ice pixels, output fromsegmentation_b.jl
ice_labels
: vector of pixel coordinates output fromfind_ice_labels.jl
cloudmask.jl
: bitmatrix cloudmask for region of interestlandmask.jl
: bitmatrix landmask for region of interestmin_area_opening
: threshold used for area opening; pixel groups greater than threshold are retained
IceFloeTracker.segmented_ice_cloudmasking
— Methodsegmented_ice_cloudmasking(gray_image, cloudmask, ice_labels;)
Apply cloudmask to a bitmatrix of segmented ice after kmeans clustering. Returns a bitmatrix with open water/clouds = 0, ice = 1).
Arguments
gray_image
: output image fromice-water-discrimination.jl
or gray ice floe leads image insegmentation_f.jl
cloudmask
: bitmatrix cloudmask for region of interestice_labels
: vector if pixel coordinates output fromfind_ice_labels.jl
IceFloeTracker.sort!
— Methodsort!(tracked::Tracked)
Sort the floes in tracked
by area in descending order.
IceFloeTracker.sort_floes_by_area!
— Methodsort_floes_by_area!(props)
Sort floes in props
by area in descending order.
IceFloeTracker.timestamp
— Methodtimestamp(fname)
Attach timestamp to fname
.
IceFloeTracker.trackercond1
— Functiontrackercond1(p1, p2, delta_time, t1=(dt = (30, 100, 1300), dist=(15, 30, 120)))
Return true
if the floe at p1
and the floe at p2
are within a certain distance of each other and the displacement time is within a certain range. Return false
otherwise.
Arguments
p1
: coordinates of floe 1p2
: coordinates of floe 2delta_time
: time elapsed from image day 1 to image day 2t
: tuple of thresholds for elapsed time and distance
IceFloeTracker.trackercond2
— Functiontrackercond2(area1, ratios, t2=(area=1200, arearatio=0.28, majaxisratio=0.10, minaxisratio=0.12, convex_area=0.14))
Set of conditions for "big" floes. Return true
if the area of the floe is greater than t2.area
and the similarity ratios are less than the corresponding thresholds in t2
. Return false
otherwise.
IceFloeTracker.trackercond3
— Functiontrackercond3(area1, ratios, t3=(area=1200, arearatio=0.18, majaxisratio=0.07, minaxisratio=0.08, convex_area=0.09))
Set of conditions for "small" floes. Return true
if the area of the floe is less than t3.area
and the similarity ratios are less than the corresponding thresholds in t3
. Return false
otherwise
IceFloeTracker.update!
— Methodupdate!(match_total::MatchedPairs, matched_pairs::MatchedPairs)
Update match_total
with the data from matched_pairs
.
IceFloeTracker.watershed_ice_floes
— Methodwatershed_ice_floes(intermediate_segmentation_image;)
Performs image processing and watershed segmentation with intermediate files from segmentation_b.jl to further isolate ice floes, returning a binary segmentation mask indicating potential sparse boundaries of ice floes.
Arguments
-intermediate_segmentation_image
: binary cloudmasked and landmasked intermediate file from segmentation B, either SegB.not_ice_bit
or SegB.ice_intersect
IceFloeTracker.watershed_product
— Methodwatershed_product(watershed_B_ice_intersect, watershed_B_not_ice;)
Intersects the outputs of watershed segmentation on intermediate files from segmentation B, indicating potential sparse boundaries of ice floes.
Arguments
watershed_B_ice_intersect
: binary segmentation mask fromwatershed_ice_floes
watershed_B_not_ice
: binary segmentation mask fromwatershed_ice_floes
IceFloeTracker.@persist
— Macro@persist img fname
@persist(img,fname)
@persist img
@persist(img)
@persist img fname ts
@persist(img, fname, ts)
Given a reference to an image object img
, the macro persists (saves to a file) img
to the current working directory using fname
as filename. Returns img
.
Arguments
img
: Symbol expression representing an image object loaded in memory.fname
: Optional filename for the persisted image.ts
: Optional boolean to attach timestamp tofname
.
IceFloeTracker.MatchedPairs
— TypeContainer for matched pairs of floes. props1
and props2
are dataframes with the same column names as the input dataframes. ratios
is a dataframe with column names area
, majoraxis
, minoraxis
, convex_area
, area_mismatch
, and corr
for similarity ratios. dist
is a vector of (pixel) distances between paired floes.
IceFloeTracker.MatchedPairs
— MethodMatchedPairs(df)
Return an object of type MatchedPairs
with an empty dataframe with the same column names as df
, an empty dataframe with column names area
, majoraxis
, minoraxis
, convex_area
, area_mismatch
, and corr
for similarity ratios, and an empty vector for distances.
IceFloeTracker.Tracked
— TypeContainer for final matched pairs of floes. data
is a vector of MatchedPairs
objects.
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