JPS（jump point search）

最新推荐文章于 2024-06-17 16:22:48 发布
最新推荐文章于 2024-06-17 16:22:48 发布
阅读量585 收藏 5
点赞数 2
分类专栏： 机器人 文章标签： JPS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuerin/article/details/116495268
版权

文章目录

  • A*算法在扩展节点过程中，会出现许多对称路径，形状类似且cost相同。这些节点会被均匀的扩散访问，最终得到规划结果时，会扩展许多无用节点。因此需要在许多类似的路径中带有倾向性的选择其中一条，节省计算资源。
  • JPS算法基本步骤与A*相同，在选择需要扩展的邻居节点中有些不同。
    • A*扩展几何上的所有相邻点，适用于栅格地图或拓扑地图。
    • JPS带有选择性的扩展邻居，以得到路径上影响运行方向的中继点，在中继点前后路段的方向不同（水平、垂直、对角）。带有倾向性的优先选择某个方向。最终生成的路径也是几何上间断的点集。但仅适用于栅格地图。
      在这里插入图片描述

1.look ahead rule

寻找邻居节点：通过父节点和子节点的连接方向，及障碍物的相对位置，选择需要扩展的邻居节点。

邻居节点的分类
  • inferior neighbors:劣性邻居，不需要扩展。判断条件：从父节点直接到达此节点的cost 比父节点经由子节点再到达此节点的cost更加cheaper, c o s t y → n cost_{y\rightarrow n} costy→n​ <= c o s t y → x → n cost_{y\rightarrow x\rightarrow n} costy→x→n​。
  • natural neighbors：天然邻居，需要扩展。判断条件：从父节点经由子节点再到达此节点的cost 更cheaper, c o s t y → n cost_{y\rightarrow n} costy→n​ > c o s t y → x → n cost_{y\rightarrow x\rightarrow n} costy→x→n​
  • forced neighbors: 强制邻居，需要扩展。判断条件：父节点直接到达此节点的cost更cheaper，但路径被障碍物挡住，只能经由子节点到达。
子节点选择扩展邻居的准则
  • 无障碍物时：当前节点x,父节点y，邻居节点n。若 c o s t y → n cost_{y\rightarrow n} costy→n​ <= c o s t y → x → n cost_{y\rightarrow x\rightarrow n} costy→x→n​，那么节点n是不需要x扩展的邻居。
  • 有障碍物时：判断是否有forced neighbor

图例：

  • 横向扩展时 （竖直向下、竖直向上、横向向左时等价）
    • 蓝色格点为父节点y，
    • 黄色格点为子节点x，
    • 黑色格点为障碍物
    • 灰色格点为inferior neighbors
    • 白色格点为 natural neighbors
    • 紫色格点为forced neighbors
      在这里插入图片描述
  • 对角扩展时 （对角左下、对角右下、对角右上等价）
    在这里插入图片描述

2. jumping rule

JPS在扩展邻居节点时，并非直接把邻居节点放入open list中，而是通过邻居节点m不断递归跳跃找到中继点(jump point)（在中继点上，路径的方向发生改变），将中继点放入open list中待扩展。

规则
  • 如果邻居节点为target node，邻居节点为jump point
  • 如果邻居节点有forced neighbor，邻居节点为jump point （代表路径在经过邻居节点时方向会发生改变）
  • 递归的横向/垂直(straight pruning rule)扩展邻居节点的同向邻居
    • 同向邻居允许通行，递归扩展同向邻居的同向邻居
    • 同向邻居为地图边界、或是障碍物，跳跃失败，没有找到跳跃点
    • 同向邻居有forced neighbor, 此同向邻居是jump point，事实上最初的邻居也是jump point, 具体见伪代码。
  • 递归的对角(diagonal pruning rule)扩展，对角向扩展一步，在此点先横向/垂直的搜索jump point, 若没找到，继续对角扩展一步

在这里插入图片描述
最终生成路径只有几个间隔的跳跃点。

3.代码

3.1整体伪代码
def Main
    起点s加进OpenList中
    While（OpenList.Count > 0）:
        从OpenList中取出f值最小的点并设置为当前点n
        把当前点n加进CloseList
        邻居点set = 获取邻居点（当前点）
        for  m : 邻居点set
            跳跃点jump_point = 递归寻找跳跃点（m）
            if (jump_point) && (jump_point not in CloseList):
                计算jump_point 的g值new_g=n.g + edge_cost(n,jump_point)
                计算jump_point 的h值
                计算new_f = g+h
                
                if (jump_point in openList) && (new_f < jump_point .f):
                    jump_point.parent_node = n
                    jump_point.g = new_g
                    jump_point.f = new_f
                else
                     jump_point.g = new_g
                     jump_point.h = h
                     jump_point.f = new_f
                     jump_point.parent_node = n
                     OpenList.add(jump_point)
3.2获取邻居节点
def 获取邻居点  
    if 当前点是起点  
        返回当前点九宫格内的非障碍点  
    elseif 当前点与父节点是对角向  
        判断并添加相对位置右方的邻居点
        判断并添加相对位置下方的邻居点
        判断并添加相对位置对角的邻居点
        判断并添加相对位置左下角的强迫邻居
        判断并添加相对位置左上角的强迫邻居
    elseif 当前点与其父节点是横向  
        判断并添加相对位置右方的邻居点
        判断并添加相对位置上方的强迫邻居
        判断并添加相对位置下方的强迫邻居
    elseif 当前点与父节点是纵向  
        同横向逻辑，判断并处理下方，左右向强迫邻居

对角向图示举例：
在这里插入图片描述

代码

public List<Point> GetNeighbors(Point point)
    {
        var points = new List<Point>();
        Point parent = point.ParentPoint;
        //起始点，扩展9宫格中非障碍物点
        if (parent == null)
        {
            //获取此点的邻居
            //起点则parent点为null，遍历邻居非障碍点加入。
            for (int x = -1; x <= 1; x++)
            {
                for (int y = -1; y <= 1; y++)
                {
                    //点自身
                    if (x == 0 && y == 0)
                        continue;

                    if (IsWalkable(x + point.X, y + point.Y))
                    {
                        points.Add(new Point(x + point.X, y + point.Y));
                    }
                }
            }
            return points;
        }

        //非起点邻居点判断(Mathf.Clamp是限制point.x - parent.x的取值范围)
        int xDirection = Mathf.Clamp(point.X - parent.X, -1, 1);
        int yDirection = Mathf.Clamp(point.Y - parent.Y, -1, 1);
        if (xDirection != 0 && yDirection != 0)
        {
            //对角方向
            bool neighbourForward =IsWalkable(point.X, point.Y + yDirection);
            bool neighbourRight =IsWalkable(point.X + xDirection, point.Y);
            bool neighbourLeft =IsWalkable(point.X - xDirection, point.Y);
            bool neighbourBack =IsWalkable(point.X, point.Y - yDirection);
            if (neighbourForward)
            {
                points.Add(new Point(point.X, point.Y + yDirection));
            }
            if (neighbourRight)
            {
                points.Add(new Point(point.X + xDirection, point.Y));
            }
            if ((neighbourForward || neighbourRight) && IsWalkable(point.X + xDirection, point.Y + yDirection))
            {
                points.Add(new Point(point.X + xDirection, point.Y + yDirection));
            }
            //强迫邻居的处理
            if (!neighbourLeft && neighbourForward)
            {
                if (IsWalkable(point.X - xDirection, point.Y + yDirection))
                {
                    points.Add(new Point(point.X - xDirection, point.Y + yDirection));
                }
            }
            if (!neighbourBack && neighbourRight)
            {
                if (IsWalkable(point.X + xDirection, point.Y - yDirection))
                {
                    points.Add(new Point(point.X + xDirection, point.Y - yDirection));
                }
            }
        }
        else
        {
            if (xDirection == 0)
            {
                //纵向
                if (IsWalkable(point.X, point.Y + yDirection))
                {
                    points.Add(new Point(point.X, point.Y + yDirection));
                    //强迫邻居
                    if (!IsWalkable(point.X + 1, point.Y) &&IsWalkable(point.X + 1, point.Y + yDirection))
                    {
                        points.Add(new Point(point.X + 1, point.Y + yDirection));
                    }
                    if (!IsWalkable(point.X - 1, point.Y) &&IsWalkable(point.X - 1, point.Y + yDirection))
                    {
                        points.Add(new Point(point.X - 1, point.Y + yDirection));
                    }
                }
            }
            else
            {
                //横向
                if (IsWalkable(point.X + xDirection, point.Y))
                {
                    points.Add(new Point(point.X, point.Y + yDirection));
                    //强迫邻居
                    if (!IsWalkable(point.X, point.Y + 1) &&IsWalkable(point.X + xDirection, point.Y + 1))
                    {
                        points.Add(new Point(point.X + xDirection, point.Y + 1));
                    }
                    if (!IsWalkable(point.X, point.Y - 1) &&IsWalkable(point.X + xDirection, point.Y - 1))
                    {
                        points.Add(new Point(point.X + xDirection, point.Y - 1));
                    }
                }
            }
        }
        return points;
    }
3.3 递归跳跃寻找jump point
def 递归寻找跳跃点(传入点，朝向：某一方向)
    if 传入点是终点
        返回终点
    if 传入朝向是对角向
        if 传入点存在强迫邻居
            返回此传入点

        if （递归寻找跳跃点 传入点：横向+1 朝向：横向）结果不为空
            返回此传入点

        if （递归寻找跳跃点 传入点：纵向+1 朝向：纵向）结果不为空
            返回此传入点
    elseif 横向
        if 上下方有强迫邻居
            返回此传入点

    elseif 纵向
        if 左右方有强迫邻居
            返回此传入点
    返回 递归寻找跳跃点(传入点按照同父节点传入方向的下一个点, 朝向:同父节点传入方向)

代码

private Point Jump(int curPosx, int curPosY, int xDirection, int yDirection, Point end)
    {
        //当前点不可行，返回空
        if (!IsWalkable(curPosx, curPosY))
            return null;
        //递归最大深度 ||  搜索到终点
        if (end.X == curPosx && end.Y == curPosY)
            return new Point(curPosx, curPosY);

        //对角向
        if (xDirection != 0 && yDirection != 0)
        {
            //如果当前点有force neighbor，当前点是一个跳点
            if ((IsWalkable(curPosx + xDirection, curPosY - yDirection) && !IsWalkable(curPosx, curPosY - yDirection)) || (IsWalkable(curPosx - xDirection, curPosY + yDirection) && !IsWalkable(curPosx - xDirection, curPosY)))
            {
                return new Point(curPosx, curPosY);
            }
            //横向递归寻找强迫邻居,如果横向有点构成跳点，那么当前点也是跳点
            if (Jump(curPosx + xDirection, curPosY, xDirection, 0, end) != null)
            {
                return new Point(curPosx, curPosY);
            }

            //纵向向递归寻找强迫邻居，如果纵向有点构成跳点，那么当前点也是跳点
            if (Jump(curPosx, curPosY + yDirection, 0, yDirection, end) != null)
            {
                return new Point(curPosx, curPosY);
            }
        }
        else if (xDirection != 0)
        {
            //横向，如果当前点有force neight，那么当前点是跳点
            if ((IsWalkable(curPosx + xDirection, curPosY + 1) && !IsWalkable(curPosx, curPosY + 1)) || (IsWalkable(curPosx + xDirection, curPosY - 1) && !IsWalkable(curPosx, curPosY - 1)))
            {
                return new Point(curPosx, curPosY);
            }
        }
        else if (yDirection != 0)
        {
            //纵向
            if ((IsWalkable(curPosx + 1, curPosY + yDirection) && !IsWalkable(curPosx + 1, curPosY)) || (IsWalkable(curPosx - 1, curPosY + yDirection) && !IsWalkable(curPosx - 1, curPosY)))
            {
                return new Point(curPosx, curPosY);
            }
        }
        //按照原方向继续扩展
        return Jump(curPosx + xDirection, curPosY + yDirection, xDirection, yDirection, end);
    }
ErinLiu虎哥的铲屎员
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Jump-Point-Search:用纯Lua编写的跳转点搜索
04-13
迷宫 纯Lua中跳转点搜索算法的实现。 用法 脚本使用txt文件作为输入和输出，分别使用“ in.txt ”和“ out.txt ”输入语法： S__xx__xxx ___xx__xx_ ___x__x_x_ xx___xx__x xxx_______ ______xxx_ ______xxxF 其中S-起点，F-终点，x-墙，_-步行空间 Ouput： S__xx__xxx * __ xx__xx_ *** x__x_x_ xx ** _ xx__x xxx ******* ______ xxx * ______xxxF 其中*-路径点 通过cmd运行solve_maze.lua resolve_maze模块返回一个函数resolve_maze（input_file，output_file） ，该函数可以使用不同的txt文件作为输入和输出运行。 附加信息 binary_heap
JPS（Jump Point Search）A*跳点搜索
08-16
JPS算法的实现！（C#版本）
JPS（Jump Point Search）跳点搜索路径规划算法回顾
最新发布
慕羽★的博客
06-17 1425
本篇文章主要回顾一下几年前学的JPS跳点搜索规划算法的相关内容，之前学的时候没有进行概括总结，现在补上
JPS(jump point search)寻路算法
lq
07-16 1万+
JPS(jump point search)寻路算法 JPS（jump point search）跳跃点寻路算法是对AStar寻路算法的一个改进。 AStar 算法在扩展节点时会把所有相邻的节点考虑进去，当地图比较大时，openList 中的节点数量会很多，搜索效率较低。 在两点之间没有障碍物时，那么中间的节点对我们来说是没有用的，不希望添加到 openList 如下 可以看到JPS 算法不是每个节点都紧密连接的，而是跳跃性的或者说只有需要转弯的节点(也叫拐点)才会被考虑，所以叫跳跃点(Jump Poin
Jump Point Search--跳点搜索法--matlab代码
03-04
1.知识：JPS算法，JPS根据当前结点current的方向、并基于跳点的策略来扩展后继节点，遵循“两个定义、三个规则”。 2.资源：JPS算法的matlab代码 3.适合人群：JPS算法的初学者
jump-point-search:Matlab中的跳转点搜索
06-09
跳跃点搜索 Matlab中的跳转点搜索
JPS_JumpPointSearch
03-17
**JPS Jump Point Search算法详解** 在游戏开发、路径规划和图形学等领域，寻找最短路径是一个常见的问题。Jump Point Search（JPS）是一种优化的A*搜索算法，旨在提高在网格环境中查找最短路径的效率。JPS由Erik ...
JPS_search_matlab-main.zip
09-03
在本项目中，我们主要关注的是两种路径规划算法——A*算法和Jump Point Search (JPS)算法。这些算法在游戏开发、机器人导航、地图探索等领域广泛应用，它们的主要任务是找到从起点到终点的最短路径。以下是这两种...
JPS算法的python实现及其可视化
08-06
JPS，全称Jump Point Search（跳跃点搜索），是一种优化的A*寻路算法，尤其适用于网格环境中的路径寻找。在游戏开发、机器人路径规划等领域，JPS能显著提高效率，降低计算量，同时保持路径质量。 A*算法是基于代价...
JumpPointSearch-master_JumpPointSearch_JPS挑点搜索算法路径规划_
09-30
**挑点搜索算法（Jump Point Search，JPS）** 挑点搜索算法，简称为JPS，是由M. Stroeven和M. A. van Gasteren在2014年提出的一种优化A*搜索算法的方法，主要用于游戏路径规划。A*算法是一种广泛应用的启发式搜索...
HexJPS:六角形网格的跳转点搜索库
05-02
"HexJPS:六角形网格的跳转点搜索库" 这个标题揭示了我们要讨论的核心内容——一个专门用于六边形网格的跳转点搜索（Jump Point Search，简称JPS）库。跳转点搜索是一种优化A*算法的路径查找技术，它减少了计算量，...
PathFindingUnity.rar
08-04
本项目"PathFindingUnity.rar"提供了一个完整的Unity工程，涵盖了AStar、Dijkstra和Jump Point Search（JPS）这三种主流的寻路算法。下面将详细解释这些算法及其在Unity中的应用。 首先，A*（A-Star）算法是一种...
jps.py 从github 上面错误的代码进行修改
11-29
jump point search 路径规划算法
矿用机器人局部路径优化算法研究
05-11
针对发生矿难后环境复杂、光线黑暗、通信不畅等问题，为了使机器人要顺利避开巷道内障碍物达到目的地展开工作，提出了一种基于JPS(jump point search)—A*的算法，在保证选出最优路径的同时，大大减少了传统A*算法在...
JPS(Jump Point Search) C# 跳点寻路算法完整代码实现
ITdqr的博客
09-05 1381
纯C#实现JPS(jump point search) 寻路算法代码提供给初学者学习
Jump Point Search-跳点搜索法-原理&matlab代码-与A*算法比较（路径规划）
bob595078694的博客
03-04 8474
本文为JPS算法的原理，示例和代码一体的学习笔记。JPS根据当前结点current的方向、并基于跳点的策略来扩展后继节点，遵循“两个定义、三个规则”。
JPS（Jump Point Search）寻路及实现代码分析
热门推荐
燕临江下的蛋
06-10 1万+
JPS（Jump Point Search）寻路 参考资料：2018腾讯移动游戏技术评审标准与实践案例 https://blog.csdn.net/yuxikuo_1/article/details/50406651 http://blog.sina.com.cn/s/blog_4a5c75d40102wo5l.html https://github.com/SkylerAlvarez/JumpP...
jump point search c++
05-13
Jump Point Search（JPS）是一种快速的路径搜索算法，它是对A*算法的优化。在搜索过程中，JPS可以有效地减少搜索的节点数，从而大大提高搜索速度。JPS算法工作原理是首先构建一颗网格图，在该图上进行搜索。当起始点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值