forked from 170010011/fr
90 lines
3.1 KiB
Python
90 lines
3.1 KiB
Python
|
from ._mcp import MCP, MCP_Geometric, MCP_Connect, MCP_Flexible
|
||
|
|
|
||
|
|
|
||
|
|
def 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. If `geometric` is False, the cost of the path is
|
||
|
|
the sum of the values of `array` along the path. If `geometric` is
|
||
|
|
True, a finer computation is made (see the documentation of the
|
||
|
|
MCP_Geometric class).
|
||
|
|
|
||
|
|
See Also
|
||
|
|
--------
|
||
|
|
MCP, MCP_Geometric
|
||
|
|
|
||
|
|
Examples
|
||
|
|
--------
|
||
|
|
>>> import numpy as np
|
||
|
|
>>> from skimage.graph import route_through_array
|
||
|
|
>>>
|
||
|
|
>>> image = np.array([[1, 3], [10, 12]])
|
||
|
|
>>> image
|
||
|
|
array([[ 1, 3],
|
||
|
|
[10, 12]])
|
||
|
|
>>> # Forbid diagonal steps
|
||
|
|
>>> route_through_array(image, [0, 0], [1, 1], fully_connected=False)
|
||
|
|
([(0, 0), (0, 1), (1, 1)], 9.5)
|
||
|
|
>>> # 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)
|
||
|
|
>>> # 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)
|
||
|
|
>>> # 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]])
|
||
|
|
>>> # Find the path with lowest cost
|
||
|
|
>>> indices, weight = route_through_array(image, (0, 0), (5, 5))
|
||
|
|
>>> indices = np.stack(indices, axis=-1)
|
||
|
|
>>> 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]])
|
||
|
|
|
||
|
|
"""
|
||
|
|
start, end = tuple(start), tuple(end)
|
||
|
|
if geometric:
|
||
|
|
mcp_class = MCP_Geometric
|
||
|
|
else:
|
||
|
|
mcp_class = MCP
|
||
|
|
m = mcp_class(array, fully_connected=fully_connected)
|
||
|
|
costs, traceback_array = m.find_costs([start], [end])
|
||
|
|
return m.traceback(end), costs[end]
|