基于A*算法的校园地图自动算路的安卓程序

算法

问题描述

在一个地图中，有一点A，中间有一道障碍，还有一点B，如下图所示，现在你要从A点出发到达B点，求出这条路径。(绿色的是起点A，红色是终点B，蓝色方块是中间的墙。)

算法过程

1.从点A开始，并且把它作为待处理点存入一个“开启列表”。开启列表就像一张购物清单。尽管现在列表里只有一个元素，但以后就会多起来。你的路径可能会通过它包含的方格，也可能不会。基本上，这是一个待检查方格的列表。
2.寻找起点周围所有可到达或者可通过的方格，跳过有墙或其他无法通过地形的方格。也把他们加入开启列表。为所有这些方格保存点A作为“父方格”。当我们想描述路径的时候，父方格的资料是十分重要的。后面会解释它的具体用途。
3.从开启列表中删除点A，把它加入到一个“关闭列表”，列表中保存所有不需要再次检查的方格。在这一点，你应该形成如图的结构。在图中，暗绿色方格是你起始方格的中心。它被用浅蓝色描边，以表示它被加入到关闭列表中了。所有的相邻格现在都在开启列表中，它们被用浅绿色描边。每个方格都有一个灰色指针反指他们的父方格，也就是开始的方格。
接着，我们选择开启列表中的临近方格，大致重复前面的过程，如下。但是，哪个方格是我们要选择的呢？是那个F值最低的。
路径评分
选择路径中经过哪个方格的关键是下面这个等式：F = G + H
这里：
G = 从起点A，沿着产生的路径，移动到网格上指定方格的移动耗费。
H = 从网格上那个方格移动到终点B的预估移动耗费。

这经常被称为启发式的，可能会让你有点迷惑。这样叫的原因是因为它只是个猜测。我们没办法事先知道路径的长度，因为路上可能存在各种障碍(墙等等)。虽然本文只提供了一种计算H的方法，但是你可以在网上找到很多其他的方法。
我们的路径是通过反复遍历开启列表并且选择具有最低F值的方格来生成的。文章将对这个过程做更详细的描述。首先，我们更深入的看看如何计算这个方程。
正如上面所说，G表示沿路径从起点到当前点的移动耗费。在这个例子里，我们令水平或者垂直移动的耗费为，对角线方向耗费为。我们取这些值是因为沿对角线的距离是沿水平或垂直移动耗费的的根号（别怕），或者约1.414倍。为了简化，我们用和近似。
既然我们在计算沿特定路径通往某个方格的G值，求值的方法就是取它父节点的G值，然后依照它相对父节点是对角线方向或者直角方向(非对角线)，分别增加和。例子中这个方法的需求会变得更多，因为我们从起点方格以外获取了不止一个方格。
H值可以用不同的方法估算。我们这里使用的方法被称为曼哈顿方法，它计算从当前格到目的格之间水平和垂直的方格的数量总和，忽略对角线方向，然后把结果乘以10。很重要的一点，我们忽略了一切障碍物。这是对剩余距离的一个估算，而非实际值，这也是这一方法被称为启发式的原因。
F的值是G和H的和。第一步搜索的结果可以在下面的图表中看到。F,G和H的评分被写在每个方格里。正如在紧挨起始格右侧的方格所表示的，F被打印在左上角，G在左下角，H则在右下角。

现在我们来看看这些方格。写字母的方格里，G = 10。这是因为它只在水平方向偏离起始格一个格距。紧邻起始格的上方，下方和左边的方格的G值都等于。对角线方向的G值是。
H值通过求解到红色目标格的曼哈顿距离得到，其中只在水平和垂直方向移动，并且忽略中间的墙。用这种方法，起点右侧紧邻的方格离红色方格有格距离，H值就是这块方格上方的方格有格距离。你大致应该知道如何计算其他方格的H值了。每个格子的F值，还是简单的由G和H相加得到

继续搜索:为了继续搜索，我们简单的从开启列表中选择F值最低的方格。然后，对选中的方格做如下处理：
4.把它从开启列表中删除，然后添加到关闭列表中。
5.检查所有相邻格子。跳过那些已经在关闭列表中的或者不可通过的(有墙其他无法通过的地形)，把他们添加进开启列表，如果他们还不在里面的话。把选中的方格作为新的方格的父节点。
6.如果某个相邻格已经在开启列表里了，检查现在的这条路径是否更好。换句话说，检查如果我们用新的路径到达它的话，G值是否会更低一些。如果不是，那就什么都不做。
另一方面，如果新的G值更低，那就把相邻方格的父节点改为目前选中的方格（在上面的图表中，把箭头的方向改为指向这个方格）。最后，重新计算F和G的值。如果这看起来不够清晰，你可以看下面的图示。
好了，让我们看看它是怎么运作的。我们最初的格方格中，在起点被切换到关闭列表中后，还剩格留在开启列表中。这里面，F值最低的那个是起始格右侧紧邻的格子，它的F值是。因此我们选择这一格作为下一个要处理的方格。在紧随的图中，它被用蓝色突出显示。
首先，我们把它从开启列表中取出，放入关闭列表(这就是他被蓝色突出显示的原因)。然后我们检查相邻的格子。哦，右侧的格子是墙，所以我们略过。左侧的格子是起始格。它在关闭列表里，所以我们也跳过它。
其他格已经在开启列表里了，于是我们检查G值来判定，如果通过这一格到达那里，路径是否更好。我们来看选中格子下面的方格。它的G值是。如果我们从当前格移动到那里，G值就会等于(到达当前格的G值是，移动到上面的格子将使得G值增加)。因为G值大于，所以这不是更好的路径。如果你看图，就能理解。与其通过先水平移动一格，再垂直移动一格，还不如直接沿对角线方向移动一格来得简单。
当我们对已经存在于开启列表中的个临近格重复这一过程的时候，我们发现没有一条路径可以通过使用当前格子得到改善，所以我们不做任何改变。既然我们已经检查过了所有邻近格，那么就可以移动到下一格了。
于是我们检索开启列表，现在里面只有7格了，我们仍然选择其中F值最低的。有趣的是，这次，有两个格子的数值都是。我们如何选择？这并不麻烦。从速度上考虑，选择最后添加进列表的格子会更快捷。这种导致了寻路过程中，在靠近目标的时候，优先使用新找到的格子的偏好。但这无关紧要。（对相同数值的不同对待，导致不同版本的A*算法找到等长的不同路径）那我们就选择起始格右下方的格子，如图：

这次，当我们检查相邻格的时候，发现右侧是墙，于是略过。上面一格也被略过。我们也略过了墙下面的格子。为什么呢？因为你不能在不穿越墙角的情况下直接到达那个格子。你的确需要先往下走然后到达那一格，按部就班的走过那个拐角。(注解：穿越拐角的规则是可选的。它取决于你的节点是如何放置的。)
这样一来，就剩下了其他格。当前格下面的另外两个格子目前不在开启列表中，于是我们添加他们，并且把当前格指定为他们的父节点。其余格，两个已经在关闭列表中（起始格，和当前格上方的格子，在表格中蓝色高亮显示),于是我们略过它们。最后一格，在当前格的左侧，将被检查通过这条路径，G值是否更低。不必担心，我们已经准备好检查开启列表中的下一格了。
我们重复这个过程，直到目标格被添加进关闭列表(注解)，就如在下面的图中所看到的。
注意，起始格下方格子的父节点已经和前面不同的。之前它的G值是，并且指向右上方的格子。现在它的G值是，指向它上方的格子。这在寻路过程中的某处发生，当应用新路径时，G值经过检查变得低了－于是父节点被重新指定，G和F值被重新计算。尽管这一变化在这个例子中并不重要，在很多场合，这种变化会导致寻路结果的巨大变化。
那么，我们怎么确定这条路径呢？很简单，从红色的目标格开始，按箭头的方向朝父节点移动。这最终会引导你回到起始格，这就是你的路径！看起来应该像图中那样。从起始格A移动到目标格B只是简单的从每个格子（节点）的中点沿路径移动到下一个，直到你到达目标点。就这么简单。

算法总结

现在你已经看完了整个说明，让我们把每一步的操作写在一起：
1.把起始格添加到开启列表。
2.重复如下的工作：
a) 寻找开启列表中F值最低的格子。我们称它为当前格。
b) 把它切换到关闭列表。
c) 对相邻的格中的每一个？
·如果它不可通过或者已经在关闭列表中，略过它。反之如下。
·如果它不在开启列表中，把它添加进去。把当前格作为这一格的父节点。记录这一格的F,G,和H值。
·如果它已经在开启列表中，用G值为参考检查新的路径是否更好。更低的G值意味着更好的路径。如果是这样，就把这一格的父节点改成当前格，并且重新计算这一格的G和F值。如果你保持你的开启列表按F值排序，改变之后你可能需要重新对开启列表排序。
d) 停止，当你
·把目标格添加进了关闭列表(注解)，这时候路径被找到，或者
没有找到目标格，开启列表已经空了。这时候，路径不存在。
3.保存路径。从目标格开始，沿着每一格的父节点移动直到回到起始格。这就是你的路径。

Python算法复现

首先将两个校区地图转换成01矩阵，1代表路，0代表障碍物

分别对应两个校区的矩阵图如下：

//良乡
01111111111111111111111111111000000000000000000000000000000000000000000
01000000000000000001100000000001110000000000000000000000000000000000000
01000000000000000001100000000000001000000000000000000000000000000000000
01111111111111111111111111111111111000000000000000000000000000000000000
01000000000000000001000000010000001000000000000000000000000000000000000
01000000000000000001000000010010001000000000000000000000000000000000000
01111111111111111111111111111110001000000000000000000000000000000000000
01001111000000000001100000011110001000000000000000000000000000000000000
01000001000000000001100000010000001000000000000000000000000000000000000
01111111111111111111111111111111111000000000000000000000000000000000000
01001111111100000001100000000000001000000000000000000000000000000000000
01001111000100000001100000000000001000111111111111111000000000000000000
01000000000100000001100000000000001000100000100000011000000000000000000
01111111111111111111111111111111111000111111111111111000000000000000000
01000000000010000001000000000001101000100010100000011000000000000000000
01111100000000000001000000000000011000100001100000011000000000000000000
01000100000000000010000000000000011000100000100000011000000000000000000
01000111111000000001100000000000101000111111111111111000000000000000000
01000000001000000001000000000000101000100000100000011000000000000000000
01000000001111100001000000000000001000100000100000011000000000000000000
01111111111111111111111111111111111111111111111111111111111111111110000
01000000001000000001000000000000001010111111111111111001000000000001111
01111111111000000001110001111110001010100001110000011010000000000000001
01000000011001111111100000000000001010100001110000011010000000000000001
01111100011111111111111111111111111010100001110000111010000000000000001
01100011001000111001111000010000001010111111111100111101001111111111111
01100011111111111111100111110000001010110001111100111101000000000000001
01111110101000010001111000010000001010100000001000111100000000000000001
01000000011000111111110000000000011010101100000110111100000000000000001
01000010011000000011110000000000001010101111111110111100000000000000001
01111111111111111111110000000000001010111111111111111111111111111111111
00000000000000000001100000000000000010000000000000011000000000000000000
00000000000000000001111111111111111111111111111111111000000000000000000
00000000000000000001100000000000000111000000000000000000000000000000000
01111111111111111111111111111111111110111111111111111111111111111111110
01000001000000000001011111000000001010000000000000000000000000000000000
01000001000000000001011111000000001010000000000000000000000000000000000
01000001000000000001111111111111001010000000000000000000000000000000000
01000001000000000001000000010000001010000000000000000000000000000000000
01111111000000000001110000011000001010000000000000000000000000000000000
01000001000000000001000001111000001010000000000000000000000000000000000
01000001000000000001000000011000001010000000000000000000000000000000000
01000001000000000001000000010000001010000000000000000000000000000000000
01111111111111111111111111111111111111111111111111110000000000000000000
01000001000000000001000000110000001010000000000000010000000000000000000
01111111000000000001000000110000001010000000000000010000000000000000000
01000001000000000001000000110000001010000000000000010000000000000000000
01000001000000000001000000110000001010100000000000010000000000000000000
01000001000000001111111111110000001010111111111111110000000000000000000
01000001000000000001000000010000001010100000000000010000000000000000000
01111111000000000001000000010000001010100000000000010000000000000000000
01000001000000000001000000011100001010111111111111110000000000000000000
01000001000000000001000000000000001010100000000000010000000000000000000
01111111000000000001111111111111111010100000000000010000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000

//中关村
00000000000000000000000000000000000000000000001111111111111111111111111111000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000001101100000100000000011001000001000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000011111111100001111111111111111111111111111000000000000000000000000000000000000000000000000000000000
00000000000000000000000000111111110000010000001100000100000000011001100011000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000010000001111111111111110000000011001100011000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000010000001000001100000001000000011001111111000000000000000000000000000000000000000000000000000000000
00000000000000000000000001111111111110000000100000000000111111111100000011000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000011111111100000000000100000010000000011000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000010010100111111111111111111111111111111000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000010011100100000000000100000010000000011000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111110000000000
00000000000000000000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000
00000000000000000000000110000000000110000000000000000001100000010000000001000010000100000000000000000001000000000000000111000000000
00000000000000000000000110000000000110000000000000000001100000010000000001000010000111111100001000000001100000000000000111000000000
00000000000000000000000110000000000110000000000000000001100000010000000001000110000110000000001000000011111111111111111111100000000
00000000000000000000000110000000000110000000000000000001100000010000000001000010000011111111111111111111000000011000000111100000000
00000000000000000000000111111111111111111111111111111111111111111111111111111111111110000000011000000001000000001000000111100000000
00000000000000000000000110000000000110000000011000000001000000000001000000000010001000000000011111111111111111111000000111100000000
00000000000000000000000110000000000110000000011000000001000000000001000000000010001111111111111000000001000000000000000111100000000
00000000000000000000000110000000000111111111111111111111111111111111000000000010000000000000001000000001111111111111111111100000000
00000000000000000000000110000000000110000000011000000000000000000001000000000010000000111111111111111111111100000110000111100000000
00000000000000000000000110001111111110000000011000000000000000000001111111111111111111111111111100000001100000000011111111110000000
00000000000000000000000110000000000110000000011000000000000000000001100000000000000000100111111111111110100000000011101111110000000
00000000000000000000000111111111111110000000011000000000000000000001100000000011111111111111110001111111110000000011111111110000000
00000000000000000000000110000000000110000000010000000000000000000001100000000111000000000111111011000010100000000011100011110000000
00000000000000000000000110000000000110000000010000000000000000000001100000000011111111110000000000000000100000000011111111110000000
00000111111111111111111110000000000110000000011000000000000000000001100000000011000000000000001111111111111111111111111111110000000
00000000100000000010000110000000000010000000011000000000000000000001100000000001111111111111111111111111110000000000000111110000000
00000000100000000010000110000000000110000000011000000000000000000001111111111111111111111000001100000000010000000000000011110000000
00000000100000000000000110000000000110000000011111111111111111111111100000000001000000000000001100000000011111111111111111111000000
00000000100000000000000110001111111110000000010000000001100000000001100000000111000000010000000100000000011000000000010001111000000
00000000100000000000000110000000000010000000010000000001100000000001100000000001110000011111111111000000011111110000000000110000000
00000011111111111111111111111111111111111111111111111111111111111111100000000000000000110000011100100000011000000000000000111000000
00000011111111111111111111111111111111111111111111111111111111111111111111111111111111100000000011111111111000000011111111111000000
00000000000000000010000000000000100010000000100000000001100000000001100000000000000000100000000011000000001000000001010001111000000
00000000001001111110000000000000100010000001100000000001100111111111100000000000000000100000000011000000001111110001010001111000000
00000000001111111111111111111111111111111111111111111111101111110011110011100000000000100000000011001000001000011011110001111000000
00000000001000000000111111000000000000000000100000000011111000000011111111100001111111111111111111111111111111111011100000111110000
00000001111111111111111111111111111111111111111111111111111111111111111111000000000010000000000100000000001000000001100000111110000
00000001111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110000
00000000000000000000000000000000000000000000000000000000000000000000000000000001111111111111111111111111111111111111111111111100000

代码为：

import numpy as np
from PIL import Image
import csv

roads = []


def txtin():
    with open("liangxiang.txt", "r") as f:
        for line in f.readlines():
            line = line.strip('\n')
            road = []
            for i in line:
                road.append(int(i) * 255)
            roads.append(road)


txtin()
img = Image.fromarray(np.uint8(roads))
img.show()
i_range = len(roads)
j_range = len(roads[0])
open_list = []
close_list = []

start_pos = [53, 1]
end_pos = [8, 27]

open_list.append([start_pos[0], start_pos[1], 0])
R_list = [] #父子关系
num = 0
path = []
while True:
    # F=G+H
    F_list = []
    # 遍历open'list，查找F最小节点
    for point in open_list:
        H = abs(point[0] - end_pos[0]) + abs(point[1] - end_pos[1])
        F_list.append(H + point[2])
    Fmin_point_index = F_list.index(min(F_list))
    Fmin_point = open_list.pop(Fmin_point_index)
    close_list.append([Fmin_point[0], Fmin_point[1]])
    for i in range(Fmin_point[0] - 1, Fmin_point[0] + 2):
        for j in range(Fmin_point[1] - 1, Fmin_point[1] + 2):
            if 0 <= i < i_range and 0 <= j < j_range:
                # 是路
                if roads[i][j] == 255 and [i, j] not in close_list:
                    tmp_point = []
                    if abs(i - Fmin_point[0]) + abs(j - Fmin_point[1]) == 2:
                        tmp_point = [i, j, Fmin_point[2] + 14]
                    elif abs(i - Fmin_point[0]) + abs(j - Fmin_point[1]) == 1:
                        tmp_point = [i, j, Fmin_point[2] + 10]

                    flag = True
                    for open_list_item in open_list:
                        if tmp_point[0] == open_list_item[0] and tmp_point[1] == open_list_item[1]:
                            if tmp_point[2] < open_list_item[2]:  # 新点距离小于老点
                                print("tmp:", tmp_point, "open_item", open_list_item)
                                open_list.pop(open_list.index(open_list_item))
                                open_list.append(tmp_point)
                                R_list.append([[Fmin_point[0], Fmin_point[1]], [i, j]])
                                flag = False
                            else:
                                flag = False

                    if flag:
                        open_list.append(tmp_point)
                        R_list.append([[Fmin_point[0], Fmin_point[1]], [i, j]])

    end_flag = False
    for open_list_item in open_list:
        if open_list_item[0] == end_pos[0] and open_list_item[1] == end_pos[1]:
            print(num)
            print(R_list)
            end_flag = True

    if end_flag:
        tmp_point = end_pos
        while True:
            for item in R_list:
                if item[1][0] == tmp_point[0] and item[1][1] == tmp_point[1]:
                    path.append(item[0])
                    tmp_point = item[0]
                    break
            if tmp_point[0] == start_pos[0] and tmp_point[1] == start_pos[1]:
                break
        print(path)
        print(num)
        break

    print(open_list)
    # print(R_list)
    num += 1


for item in path:
    roads[item[0]][item[1]] = 127
img = Image.fromarray(np.uint8(roads))
img.show()

复现效果

初始地图

灰色标记为寻找的路线

实现效果

安卓程序

效果展示

基于A*算法的校园地图自动算路的安卓程序

程序先选择起点和终点，支持两个终点，如若第二个不选则默认为只有一个终点

只有一个终点时的寻路效果，红线即为路

有两个终点时

红线为起点至第一个终点的线路，黄线为第一个终点至第二个终点的线路

核心代码

package com.zhj.schoolmap

import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Color
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.android.synthetic.main.activity_show_liang.*
import java.io.InputStreamReader
import kotlin.math.abs

class ShowZhongActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_show_zhong)

        //初始信息
        val pref = this.getSharedPreferences("search", MODE_PRIVATE)
        val from_x = pref.getInt("from_x", 0)
        val from_y = pref.getInt("from_y", 0)
        val to_x = pref.getInt("to_x", 0)
        val to_y = pref.getInt("to_y", 0)
        //Log.i("show","$from_x-$from_y-$to_x-$to_y")


        //读入地图
        val liang_res = resources.openRawResource(R.raw.zhongguancun)
        val bufReader = InputStreamReader(liang_res, "utf8")
        var liang_map = emptyArray<Array<Int>>()
        bufReader.useLines { lines ->
            for (line in lines) {
                var row = emptyArray<Int>()
                for (i in line) {
                    row = row.plus(i.toInt() - 48)
                }
                liang_map = liang_map.plus(row)
            }
        }

        //val show = liang_map[from_x][from_y]
        //val showt = liang_map[to_x][to_y]
        //Log.i("show","$show $showt")

        //算法开始
        var open_list = mutableListOf(mutableListOf(from_x, from_y, 0))
        var close_list = mutableListOf<List<Int>>()
        val i_range = liang_map.size
        val j_range = liang_map[0].size
        var num = 0
        var R_list = mutableListOf<List<Int>>()
        var path = mutableListOf<List<Int>>()

        while (true) {
            var F_list = mutableListOf<Int>()
            for (point in open_list) {
                val H = abs(point[0] - to_x) + abs(point[1] - to_y)
                F_list.add(H + point[2])
            }

            val Fmin_point_index = F_list.indexOf(F_list.minOrNull())
            val Fmin_point = open_list[Fmin_point_index]
            open_list.removeAt(Fmin_point_index)
            close_list.add(mutableListOf(Fmin_point[0], Fmin_point[1]))
            for (i in (Fmin_point[0] - 1)..(Fmin_point[0] + 1)) {
                for (j in (Fmin_point[1] - 1)..(Fmin_point[1] + 1)) {
                    //Log.i("show", "$i-$j " + (i in 0 until i_range) + (j in 0 until j_range))
                    if (i in 0 until i_range && j in 0 until j_range) {
                        if (liang_map[i][j] == 1 && !close_list.contains(listOf(i, j))) {//是路
                            var tmp_point = listOf<Int>()
                            if (abs(i - Fmin_point[0]) + abs(j - Fmin_point[1]) == 2) {
                                tmp_point = listOf(i, j, Fmin_point[2] + 14)
                            } else if (abs(i - Fmin_point[0]) + abs(j - Fmin_point[1]) == 1) {
                                tmp_point = listOf(i, j, Fmin_point[2] + 10)
                            }

                            if (tmp_point.isNotEmpty()) {
                                var flag = true
                                for (open_list_item in open_list) {
                                    if (tmp_point[0] == open_list_item[0] && tmp_point[1] == open_list_item[1]) {
                                        if (tmp_point[2] < open_list_item[2]) {//新点距离小于老点
                                            open_list.removeAt(open_list.indexOf(open_list_item))
                                            open_list.add(tmp_point as MutableList<Int>)
                                            R_list.add(listOf(Fmin_point[0], Fmin_point[1], i, j))
                                            flag = false
                                            break
                                        } else {
                                            flag = false
                                        }
                                    }
                                }

                                if (flag) {
                                    open_list.add(tmp_point as MutableList<Int>)
                                    R_list.add(listOf(Fmin_point[0], Fmin_point[1], i, j))
                                }
                            }
                        }
                    }
                }
            }

            var end_flag = false
            for (open_list_item in open_list) {
                if (open_list_item[0] == to_x && open_list_item[1] == to_y) {
                    end_flag = true
                }
            }
            if (end_flag) {
                var tmp_point = mutableListOf(to_x, to_y)
                path.add(listOf(to_x, to_y))
                while (true) {
                    for (item in R_list) {
                        if (item[2] == tmp_point[0] && item[3] == tmp_point[1]) {
                            path.add(listOf(item[0], item[1]))
                            tmp_point[0] = item[0]
                            tmp_point[1] = item[1]
                        }
                    }
                    if (tmp_point[0] == from_x && tmp_point[1] == from_y) {
                        break
                    }
                }
                Log.i("show", path.toString())
                break
            }
            num += 1
        }

        val pic = resources.getIdentifier("zhong", "drawable", packageName)
        val res = BitmapFactory.decodeResource(resources, pic)
        val new = Bitmap.createBitmap(res.width, res.height, Bitmap.Config.ARGB_8888)
        for (i in 0 until new.width) {
            for (j in 0 until new.height) {
                val color = res.getColor(i, j).toArgb()
                new.setPixel(i, j, color)
            }
        }

        for (point in path) {
            val point_x = (90 + 9.77 * point[1]).toInt()
            val point_y = (250 + 16.6 * point[0]).toInt()

            for (i in point_x..(point_x + 10)) {
                for (j in point_y..(point_y + 10)) {
                    new.setPixel(i, j, Color.argb(255, 255, 0, 0))
                }
            }
        }
        //Log.i("show","${new.width} - ${new.height}")

        imageView.setImageBitmap(new)
    }
}

源码地址

Github地址

展示视频

bilibili地址

Apk下载地址

站内apk下载地址