hagelslag.processing package¶

Submodules¶

hagelslag.processing.EnhancedWatershedSegmenter module¶

@author: David John Gagne (djgagne@ou.edu)

class hagelslag.processing.EnhancedWatershedSegmenter.EnhancedWatershed(min_intensity, data_increment, max_intensity, size_threshold_pixels, delta)¶

Bases: object

The enhanced watershed performs image segmentation using a modified version of the traditional watershed technique. It includes a size criteria and creates foothills around each object to keep them distinct. The object is used to store the quantization and size parameters. It can be used to watershed multiple grids.

min_intensity¶

minimum pixel value for pixel to be part of a region

Type:: int

data_increment¶

quantization interval. Use 1 if you don’t want to quantize

Type:: int

max_intensity¶

values greater than maxThresh are treated as the maximum threshold

Type:: int

size_threshold_pixels¶

clusters smaller than this threshold are ignored.

Type:: int

delta¶

maximum number of data increments the cluster is allowed to range over. Larger d results in clusters over larger scales.

Type:: int

find_local_maxima(pixels, q_data)¶

Finds the local maxima in the inputGrid and perform region growing to identify objects.

Parameters:

pixels – dictionary of quantized pixel values
q_data – 2D array representation of quantized input data

Returns:

array with labeled objects.

grow_centers(centers, q_data)¶

Once

Parameters:

centers –
q_data –

Returns:

static is_closest(point, center, centers, bin_num)¶

static is_valid(point, shape)¶

label(input_grid, only_objects=True)¶

Labels input grid using enhanced watershed algorithm.

Parameters:

input_grid (numpy.ndarray) – Grid to be labeled.
only_objects (bool) – Only return object pixel values on final grid

Returns:

Array of labeled pixels

quantize(input_grid)¶

Quantize a grid into discrete steps based on input parameters.

Parameters:: input_grid – 2-d array of values
Returns:: Dictionary of value pointing to pixel locations, and quantized 2-d array of data

remove_foothills(q_data, marked, bin_num, bin_lower, centers, foothills)¶

Mark points determined to be foothills as globbed, so that they are not included in future searches. Also searches neighboring points to foothill points to determine if they should also be considered foothills.

Parameters:

q_data – Quantized data
marked – Marked
bin_num – Current bin being searched
bin_lower – Next bin being searched
centers – dictionary of local maxima considered to be object centers
foothills – List of foothill points being removed.

set_maximum(q_data, marked, center, bin_lower, foothills, capture_index)¶

Grow a region at a certain bin level and check if the region has reached the maximum size.

Parameters:

q_data – Quantized data array
marked – Array marking points that are objects
center – Coordinates of the center pixel of the region being grown
bin_lower – Intensity level of lower bin being evaluated
foothills – List of points that are associated with a center but fall outside the the size or intensity criteria
capture_index –

Returns:

True if the object is finished growing and False if the object should be grown again at the next threshold level.

static size_filter(labeled_grid, min_size)¶

Removes labeled objects that are smaller than min_size, and relabels the remaining objects.

Parameters:

labeled_grid – Grid that has been labeled
min_size – Minimium object size.

Returns:

Labeled array with re-numbered objects to account for those that have been removed

hagelslag.processing.EnhancedWatershedSegmenter.rescale_data(data, data_min, data_max, out_min=0.0, out_max=100.0)¶

Rescale your input data so that is ranges over integer values, which will perform better in the watershed.

Parameters:

data – 2D or 3D ndarray being rescaled
data_min – minimum value of input data for scaling purposes
data_max – maximum value of input data for scaling purposes
out_min – minimum value of scaled data
out_max – maximum value of scaled data

Returns:

Linearly scaled ndarray

hagelslag.processing.EnsembleProducts module¶

hagelslag.processing.Hysteresis module¶

hagelslag.processing.ObjectMatcher module¶

class hagelslag.processing.ObjectMatcher.ObjectMatcher(cost_function_components, weights, max_values)¶

Bases: object

ObjectMatcher calculates distances between two sets of objects and determines the optimal object assignments based on the Hungarian object matching algorithm. ObjectMatcher supports the use of the weighted average of multiple cost functions to determine the distance between objects. Upper limits to each distance component are used to exclude the matching of objects that are too far apart.

cost_function_components¶: List of distance functions for matching

weights¶: List of weights for each distance function

max_values¶: List of the maximum allowable distance for each distance function component.

cost_matrix(set_a, set_b, time_a, time_b)¶

Calculates the costs (distances) between the items in set a and set b at the specified times.

Parameters:

set_a – List of STObjects
set_b – List of STObjects
time_a – time at which objects in set_a are evaluated
time_b – time at whcih object in set_b are evaluated

Returns:

A numpy array with shape [len(set_a), len(set_b)] containing the cost matrix between the items in set a and the items in set b.

match_objects(set_a, set_b, time_a, time_b)¶

Match two sets of objects at particular times.

Parameters:

set_a – list of STObjects
set_b – list of STObjects
time_a – time at which set_a is being evaluated for matching
time_b – time at which set_b is being evaluated for matching

Returns:

List of tuples containing (set_a index, set_b index) for each match

total_cost_function(item_a, item_b, time_a, time_b)¶

Calculate total cost function between two items.

Parameters:

item_a – STObject
item_b – STObject
time_a – Timestep in item_a at which cost function is evaluated
time_b – Timestep in item_b at which cost function is evaluated

Returns:

The total weighted distance between item_a and item_b

class hagelslag.processing.ObjectMatcher.TrackMatcher(cost_function_components, weights, max_values)¶

Bases: object

Find the optimal pairings among two sets of STObject tracks.

cost_function_components¶: Array of cost function objects

weights¶: Array of weights for each cost function. All should sum to 1.

max_values¶: Array of distance values that correspond to the upper limit distance that should be considered.

match_tracks(set_a, set_b, closest_matches=False)¶

Find the optimal set of matching assignments between set a and set b. This function supports optimal 1:1 matching using the Munkres method and matching from every object in set a to the closest object in set b. In this situation set b accepts multiple matches from set a.

Parameters:

set_a –
set_b –
closest_matches –

Returns:

neighbor_matches(set_a, set_b)¶

raw_cost_matrix(set_a, set_b)¶

track_cost_function(item_a, item_b)¶

track_cost_matrix(set_a, set_b)¶

class hagelslag.processing.ObjectMatcher.TrackStepMatcher(cost_function_components, max_values)¶

Bases: object

Determine if each step in a track is in close proximity to steps from another set of tracks

cost(track_a, time_a, track_b, time_b)¶

cost_matrix(set_a, set_b)¶

match(set_a, set_b)¶

For each step in each track from set_a, identify all steps in all tracks from set_b that meet all cost function criteria

Parameters:

set_a – List of STObjects
set_b – List of STObjects

Returns:

pandas.DataFrame

Return type:

track_pairings

hagelslag.processing.ObjectMatcher.area_difference(item_a, time_a, item_b, time_b, max_value)¶

RMS Difference in object areas.

Parameters:

item_a – STObject from the first set in ObjectMatcher
time_a – Time integer being evaluated
item_b – STObject from the second set in ObjectMatcher
time_b – Time integer being evaluated
max_value – Maximum distance value used as scaling value and upper constraint.

Returns: