route_through_array(array, start, end, fully_connected=True, geometric=True)

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. If :None:None:`geometric` is False, the cost of the path is the sum of the values of array along the path. If :None:None:`geometric` is True, a finer computation is made (see the documentation of the MCP_Geometric class).

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

See Also

MCP

MCP_Geometric

Examples

This example is valid syntax, but we were not able to check execution

>>> import numpy as np
... from skimage.graph import route_through_array
>>>

This example is valid syntax, but we were not able to check execution

>>> image = np.array([[1, 3], [10, 12]])
... image
array([[ 1,  3],
       [10, 12]])

This example is valid syntax, but we were not able to check execution

>>> # Forbid diagonal steps
... route_through_array(image, [0, 0], [1, 1], fully_connected=False)
([(0, 0), (0, 1), (1, 1)], 9.5)

This example is valid syntax, but we were not able to check execution

>>> # Now allow diagonal steps: the path goes directly from start to end
... route_through_array(image, [0, 0], [1, 1])
([(0, 0), (1, 1)], 9.19238815542512)

This example is valid syntax, but we were not able to check execution

>>> # Cost is the sum of array values along the path (16 = 1 + 3 + 12)
... route_through_array(image, [0, 0], [1, 1], fully_connected=False,
... geometric=False)
([(0, 0), (0, 1), (1, 1)], 16.0)

This example is valid syntax, but we were not able to check execution

>>> # Larger array where we display the path that is selected
... image = np.arange((36)).reshape((6, 6))
... image
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])

This example is valid syntax, but we were not able to check execution

>>> # Find the path with lowest cost
... indices, weight = route_through_array(image, (0, 0), (5, 5))
... indices = np.array(indices).T
... path = np.zeros_like(image)
... path[indices[0], indices[1]] = 1
... path
array([[1, 1, 1, 1, 1, 0],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1]])

See :

Back References

The following pages refer to to this document either explicitly or contain code examples using this.

skimage.graph.mcp.route_through_array

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

File: /skimage/graph/mcp.py#4
type: <class 'function'>
Commit: