Module: graph

Inheritance diagram for skimage.graph:

MCP

class skimage.graph.MCP(costs, offsets=None, fully_connected=True)

Bases: object

A class for finding the minimum cost path through a given n-d costs array.

Given an n-d costs array, this class can be used to find the minimum-cost path through that array from any set of points to any other set of points. Basic usage is to initialize the class and call find_costs() with a one or more starting indices (and an optional list of end indices). After that, call traceback() one or more times to find the path from any given end-position to the closest starting index. New paths through the same costs array can be found by calling find_costs() repeatedly.

The cost of a path is calculated simply as the sum of the values of the costs array at each point on the path. The class MCP_Geometric, on the other hand, accounts for the fact that diagonal vs. axial moves are of different lengths, and weights the path cost accordingly.

Array elements with infinite or negative costs will simply be ignored, as will paths whose cumulative cost overflows to infinite.

Parameters :

costs : ndarray

offsets : iterable, optional

A list of offset tuples: each offset specifies a valid move from a given n-d position. If not provided, offsets corresponding to a singly- or fully-connected n-d neighborhood will be constructed with make_offsets(), using the fully_connected parameter value.

fully_connected : bool, optional

If no offsets are provided, this determines the connectivity of the generated neighborhood. If true, the path may go along diagonals between elements of the costs array; otherwise only axial moves are permitted.

Attributes

offsets

Methods

find_costs	Find the minimum-cost path from the given starting points.
traceback(end)	Trace a minimum cost path through the pre-calculated traceback array.

__init__(costs, offsets=None, fully_connected=True)

See class documentation.

find_costs()

Find the minimum-cost path from the given starting points.

This method finds the minimum-cost path to the specified ending indices from any one of the specified starting indices. If no end positions are given, then the minimum-cost path to every position in the costs array will be found.

Parameters :

starts : iterable

A list of n-d starting indices (where n is the dimension of the costs array). The minimum cost path to the closest/cheapest starting point will be found.

ends : iterable, optional

A list of n-d ending indices.

find_all_ends : bool, optional

If ‘True’ (default), the minimum-cost-path to every specified end-position will be found; otherwise the algorithm will stop when a a path is found to any end-position. (If no ends were specified, then this parameter has no effect.)

Returns :

cumulative_costs : ndarray

Same shape as the costs array; this array records the minimum cost path from the nearest/cheapest starting index to each index considered. (If ends were specified, not all elements in the array will necessarily be considered: positions not evaluated will have a cumulative cost of inf. If find_all_ends is ‘False’, only one of the specified end-positions will have a finite cumulative cost.)

traceback : ndarray

Same shape as the costs array; this array contains the offset to any given index from its predecessor index. The offset indices index into the offsets attribute, which is a array of n-d offsets. In the 2-d case, if offsets[traceback[x, y]] is (-1, -1), that means that the predecessor of [x, y] in the minimum cost path to some start position is [x+1, y+1]. Note that if the offset_index is -1, then the given index was not considered.

offsets

traceback(end)

Trace a minimum cost path through the pre-calculated traceback array.

This convenience function reconstructs the the minimum cost path to a given end position from one of the starting indices provided to find_costs(), which must have been called previously. This function can be called as many times as desired after find_costs() has been run.

Parameters :

end : iterable

An n-d index into the costs array.

Returns :

traceback : list of n-d tuples

A list of indices into the costs array, starting with one of the start positions passed to find_costs(), and ending with the given end index. These indices specify the minimum-cost path from any given start index to the end index. (The total cost of that path can be read out from the cumulative_costs array returned by find_costs().)

MCP_Geometric

class skimage.graph.MCP_Geometric(costs, offsets=None, fully_connected=True)

Bases: skimage.graph._mcp.MCP

Find distance-weighted minimum cost paths through an n-d costs array.

See the documentation for MCP for full details. This class differs from MCP in that the cost of a path is not simply the sum of the costs along that path.

This class instead assumes that the costs array contains at each position the “cost” of a unit distance of travel through that position. For example, a move (in 2-d) from (1, 1) to (1, 2) is assumed to originate in the center of the pixel (1, 1) and terminate in the center of (1, 2). The entire move is of distance 1, half through (1, 1) and half through (1, 2); thus the cost of that move is (1/2)*costs[1,1] + (1/2)*costs[1,2].

On the other hand, a move from (1, 1) to (2, 2) is along the diagonal and is sqrt(2) in length. Half of this move is within the pixel (1, 1) and the other half in (2, 2), so the cost of this move is calculated as (sqrt(2)/2)*costs[1,1] + (sqrt(2)/2)*costs[2,2].

These calculations don’t make a lot of sense with offsets of magnitude greater than 1.

Methods

find_costs	Find the minimum-cost path from the given starting points.
traceback(end)	Trace a minimum cost path through the pre-calculated traceback array.

__init__(costs, offsets=None, fully_connected=True)

See class documentation.

find_costs()

Find the minimum-cost path from the given starting points.

This method finds the minimum-cost path to the specified ending indices from any one of the specified starting indices. If no end positions are given, then the minimum-cost path to every position in the costs array will be found.

Parameters :

starts : iterable

A list of n-d starting indices (where n is the dimension of the costs array). The minimum cost path to the closest/cheapest starting point will be found.

ends : iterable, optional

A list of n-d ending indices.

find_all_ends : bool, optional

If ‘True’ (default), the minimum-cost-path to every specified end-position will be found; otherwise the algorithm will stop when a a path is found to any end-position. (If no ends were specified, then this parameter has no effect.)

Returns :

cumulative_costs : ndarray

Same shape as the costs array; this array records the minimum cost path from the nearest/cheapest starting index to each index considered. (If ends were specified, not all elements in the array will necessarily be considered: positions not evaluated will have a cumulative cost of inf. If find_all_ends is ‘False’, only one of the specified end-positions will have a finite cumulative cost.)

traceback : ndarray

Same shape as the costs array; this array contains the offset to any given index from its predecessor index. The offset indices index into the offsets attribute, which is a array of n-d offsets. In the 2-d case, if offsets[traceback[x, y]] is (-1, -1), that means that the predecessor of [x, y] in the minimum cost path to some start position is [x+1, y+1]. Note that if the offset_index is -1, then the given index was not considered.

offsets

traceback(end)

Trace a minimum cost path through the pre-calculated traceback array.

This convenience function reconstructs the the minimum cost path to a given end position from one of the starting indices provided to find_costs(), which must have been called previously. This function can be called as many times as desired after find_costs() has been run.

Parameters :

end : iterable

An n-d index into the costs array.

Returns :

traceback : list of n-d tuples

A list of indices into the costs array, starting with one of the start positions passed to find_costs(), and ending with the given end index. These indices specify the minimum-cost path from any given start index to the end index. (The total cost of that path can be read out from the cumulative_costs array returned by find_costs().)

skimage.graph.route_through_array(array, ...)	Simple example of how to use the MCP and MCP_Geometric classes.
skimage.graph.shortest_path(arr[, reach, ...])	Find the shortest path through an n-d array from one side to another.

route_through_array

skimage.graph.route_through_array(array, start, end, fully_connected=True, geometric=True)

Simple example of how to use the MCP and MCP_Geometric classes.

See the MCP and MCP_Geometric class documentation for explanation of the path-finding algorithm.

Parameters :

array : ndarray

Array of costs.

start : iterable

n-d index into array defining the starting point

end : iterable

n-d index into array defining the end point

fully_connected : bool (optional)

If True, diagonal moves are permitted, if False, only axial moves.

geometric : bool (optional)

If True, the MCP_Geometric class is used to calculate costs, if False, the MCP base class is used. See the class documentation for an explanation of the differences between MCP and MCP_Geometric.

Returns :

path : list

List of n-d index tuples defining the path from start to end.

cost : float

Cost of the path.

shortest_path

skimage.graph.shortest_path(arr, reach=1, axis=-1, output_indexlist=False)

Find the shortest path through an n-d array from one side to another.

Parameters :

arr : ndarray of float64

reach : int, optional

By default (reach = 1), the shortest path can only move one row up or down for every step it moves forward (i.e., the path gradient is limited to 1). reach defines the number of elements that can be skipped along each non-axis dimension at each step.

axis : int, optional

The axis along which the path must always move forward (default -1)

output_indexlist: bool, optional :

See return value p for explanation.

Returns :

p : iterable of int

For each step along axis, the coordinate of the shortest path. If output_indexlist is True, then the path is returned as a list of n-d tuples that index into arr. If False, then the path is returned as an array listing the coordinates of the path along the non-axis dimensions for each step along the axis dimension. That is, p.shape == (arr.shape[axis], arr.ndim-1) except that p is squeezed before returning so if arr.ndim == 2, then p.shape == (arr.shape[axis],)

cost : float

Cost of path. This is the absolute sum of all the differences along the path.