计算python

Question

我有一个黑白位图图像显示在这里：

图像尺寸为200,158。

我想选择落在白色路径上的两个点，并计算仅跟随白色像素的那两个点之间的最短距离。我不知道如何解决这个问题。我想用2组x，y坐标创建一个函数，它只返回沿着白色像素的最短路径的像素数。

任何指针都会非常感激。

Answer 1

如评论中所述，此问题可以缩短为Dijkstra。

解决方案背后的关键概念是将图像表示为图形，然后使用预先实现的最短路径算法。

首先，观察大小为4x4的图像的天真表示：

T F F T
T T F T
F T T F
T T T T

T是白点，F是黑点。在这种情况下，路径是相邻白点之间的一组移动。

假设图表是一组节点{1, 2, ..., 16}，我们可以将每个点(i, j)映射到数字i * 4 + j。在图表中，边缘是相邻点的反射，这意味着如果(i1, j1)和(i2, j2)在图像中相邻，则i1 * 4 + j1和i2 * 4 + j2在图表中相邻

此时，我们有一个图表，我们可以在其中计算最短路径。

幸运的是，python为图像加载和最短路径实现提供了简单的实现。以下代码处理可视化结果的路径计算：

import itertools

from scipy import misc
from scipy.sparse.dok import dok_matrix
from scipy.sparse.csgraph import dijkstra

# Load the image from disk as a numpy ndarray
original_img = misc.imread('path_t_image')

# Create a flat color image for graph building:
img = original_img[:, :, 0] + original_img[:, :, 1] + original_img[:, :, 2]


# Defines a translation from 2 coordinates to a single number
def to_index(y, x):
    return y * img.shape[1] + x


# Defines a reversed translation from index to 2 coordinates
def to_coordinates(index):
    return index / img.shape[1], index % img.shape[1]


# A sparse adjacency matrix.
# Two pixels are adjacent in the graph if both are painted.
adjacency = dok_matrix((img.shape[0] * img.shape[1],
                        img.shape[0] * img.shape[1]), dtype=bool)

# The following lines fills the adjacency matrix by
directions = list(itertools.product([0, 1, -1], [0, 1, -1]))
for i in range(1, img.shape[0] - 1):
    for j in range(1, img.shape[1] - 1):
        if not img[i, j]:
            continue

        for y_diff, x_diff in directions:
            if img[i + y_diff, j + x_diff]:
                adjacency[to_index(i, j),
                          to_index(i + y_diff, j + x_diff)] = True

# We chose two arbitrary points, which we know are connected
source = to_index(14, 47)
target = to_index(151, 122)

# Compute the shortest path between the source and all other points in the image
_, predecessors = dijkstra(adjacency, directed=False, indices=[source],
                           unweighted=True, return_predecessors=True)

# Constructs the path between source and target
pixel_index = target
pixels_path = []
while pixel_index != source:
    pixels_path.append(pixel_index)
    pixel_index = predecessors[0, pixel_index]


# The following code is just for debugging and it visualizes the chosen path
import matplotlib.pyplot as plt

for pixel_index in pixels_path:
    i, j = to_coordinates(pixel_index)
    original_img[i, j, 0] = original_img[i, j, 1] = 0

plt.imshow(original_img)
plt.show()

声明：

• 我没有图像处理经验，所以我怀疑解决方案的每一步。
• 该解决方案假设一个非常天真的邻接谓词。这部分的计算几何可能有一些更好的方法。

Answer 2

skimage.graph具有专门用于图像的Dijkstra实现，可通过几行代码解决您的问题：

import numpy as np
import skimage.graph

T,F = True,False
array = np.asarray(
    [[T, F, F, T],
     [T, T, F, T],
     [F, T, T, F],
     [T, T, T, T]])
costs = np.where(array, 1, 1000)
path, cost = skimage.graph.route_through_array(
    costs, start=(0,0), end=(3,3), fully_connected=True)

在此示例中，path等于[（0，0），（1，1），（2，2），（3，3）]，这确实是最短的路径。

Answer 3

Hello mmiltonjbradley，

我不是这类算法的专家，但至少我可以通过给你一些线索来帮助你。 我过去常常在学校做类似的项目。当时，我们正在考虑两种算法：蚁群优化算法和遗传算法。

蚁群优化

这些算法基于蚂蚁的行为，当他们试图找到最简单和最短路径的某些食物时。更多信息：https://en.wikipedia.org/wiki/Ant_colony_optimization_algorithms。

遗传算法

它们更通用，可以适应很多问题。 根据您的情况，您可能对this paper感兴趣。

对不起，我无法为您提供更详细的帮助。我让其他人回答，给你你需要的宝贵建议。祝你的项目好运，无论如何！

度过愉快的一天，

马蒂斯。