C++实现 JPS算法(Jump Point Search)

已于 2023-03-20 11:52:56 修改
阅读量2.2k 收藏 16
点赞数 5
文章标签： c++ 算法
于 2023-03-17 19:01:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63608714/article/details/129626493
版权
JPS算法是A*算法的一种高效实现，主要通过跳点策略减少搜索空间，提高寻路效率。在有障碍的地图中，JPS只考虑具有‘价值’的节点，即强迫邻居节点，从而减少无效计算。算法涉及方向判断、跳点识别以及递归过程，适用于游戏中的角色移动和路径计算。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JumpPoint Search算法（JPS算法）

JPS算法全称为Jump PointSearch，也就是跳点算法，可以视为A*算法的一种改进算法，它保留了A*算法的主体框架，区别在于：A*算法是将当前节点的所有未访问邻居节点加入openlist，而JPS则是使用一些方法将有“价值”的节点加入openlist，具体方法就是本文的内容。

了解A*算法再来看JPS算法将会事半功倍

原理: 如果p经过x点到达n, 比不经过x点到达n的距离代价都小, 那么n是x点的强迫邻居, x为跳点，

x的父亲为p

  1. 开销

公式: f = gCost + hCost

gCost: 开始点到当前点的实际距离代价

hCos: 当前点到目标点的估计距离代价

f: 总开销

二．方向(8个方向)

分别为右, 右上, 上, 左上, 左, 左下, 下, 右下

图一:

p为openList找出来行走的点

因为x点上方有阻碍物, 并且右上方有强迫邻居x1, 所以x为跳点, x的(方向)向右, x的(父亲)为p, 返回判断是否加入openList, 重新在openList找行走的点

图二:

因为p点右上方和右下方都有强迫邻居,

1. p向右走, x3点有邻居, 所以x3是跳点

所以x1, x2, x3都为跳点, (方向)分别是右上, 右下, 右, (父亲)都为p点

图三:

图四:

如图四, 单个点分析

1.因为p为斜方向的点, 所以有三个方向要走分别是上(l点开始), 右上(d点开始), 右(r点开始),

2.如果d点有强迫邻居返回d点, d点位跳点, d点的(方向)为右上, (父亲)为p, 返回, 如果没有进入第三步

3.那么就需要d点的上方向和右方向判断是否有跳点, 如果有, d点为跳点, d点的方向为右上, (父亲)为p, 返回, 如果没有进入第四步

4.d点向右上方向, 前进一步到达d2, 重复2步骤

如图三

因为p点上, 右上和右都有邻居, 所以p1(方向左上), p3(方向右上), p6(方向右下)都为跳点, (父亲)都为p点, 返回判断是否加入openList 重新在openList找行走的点

图五:

1.因为p点上方向, 左方向堵了, 所以只有p1点左上方向可以做跳点判断

因为p点有两个邻居p2, p3, 所以p1为跳点, 方向左上, 父亲为p, 返回判断是否加入openList, 重新在openList找行走的点

图六:

因为p点有邻居p1, p2, 所以p1(方向左下), p2(方向右上), 都为跳点, 父亲为p点

1.因为p为斜方向的点, 所以有三个方向要走分别是上,左上, 左

2.因为p5有邻居, 所以p5为跳点(方向左)

2.因为p3左方向p4有邻居, 所以p3为跳点(方向左上)

所以p1(方向左下), p2(方向右上), p5(方向左), p3(方向左上)都为跳点, (父亲)都为p点

代码:

//enum 方向              右   右上 上  左上 左  左下 下  右下
const int32 DirX[8] = { 1,  1,  0, -1, -1, -1,  0,  1 };
const int32 DirY[8] = { 0,  1,  1,  1,  0, -1, -1, -1 };

1.跳点算法获取最短的开销路径:

void JpsFind::CalcPath()
    {
        while( !openL_.empty() )
        {
            NodePtr current = openL_.front();
            if( !current )
                return;

            if( endNode_->x == current->x && endNode_->y == current->y )
            {
                endNode_ = current;
                return;
            }

            map_mgr_.TryViewEveryPointPath(current);//(忽略,该函数用于展示轨迹)

            openL_.pop_front();
            closeL_.insert((current->x<<16)|current->y);

            std::vector<NodePtr> nL = GetSuccessJumpNodeL(current);
            if( !nL.empty() )
            {
                for( const auto& m : nL )
                {
                    if( FindByCloseL(m) )//是否在closeList
                        continue;
                    
                    NodePtr is_open = FindByOpenL(m);

                    int32 newGcost = current->gCost + GetDistance(current->x, current->y, m->x, m->y);
                    if( newGcost < m->gCost || !is_open )
                    {
                        m->gCost = newGcost;
                        m->hCost = GetDistance(m->x, m->y, endNode_->x, endNode_->y);
                        m->parent = current;//设置父亲归属
                        if( !is_open )
                        {
                            AddToOpenL(m);
                        }
                    }
                }
            }
        }
    }

  1. 获取当前点的有关跳点列表

std::vector<NodePtr> JpsFind::GetSuccessJumpNodeL( const NodePtr& node )
    {
        std::vector<NodePtr> nL = GetForceNodeL(node);//强迫邻居
        
        for( const auto& m : GetNeighbours(node) )//当前点可以行走的方向
        {
            NodePtr jps_node = Jump(m, m->dir);//递归行走点, 返回跳点
            if( !jps_node )
                continue;

            nL.push_back(jps_node);
        }

        return nL;
    }

  1. 递归返回对应跳点

NodePtr JpsFind::Jump( const NodePtr& node, int32 dir )
    {
        map_mgr_.TryViewEveryPointPath(node);//(忽略,该函数用于展示轨迹)

        if( !node || !Walk(node->x, node->y) )//是否可行走
            return NodePtr();

        if( node->x == endNode_->x && node->y == endNode_->y )
        {
            jpsN_ = true;
            return node;
        }

        jpsN_ = false;//用于判断斜线方向是否有跳点

        if( dir%2 == 1 )
        {
            return JumpInclined(node, dir);//斜线方向
        }

        return JumpStr(node, dir);
    }

  1. 斜线方向递归

NodePtr JpsFind::JumpInclined( const NodePtr& node, int32 dir )
    {
        //斜方向
        int32 l_dir = (dir + 3) % 8;
        int32 r_dir = (dir + 5) % 8;
        //斜线交叉方向是否墙
        bool l_force_ = Walk(node->x + DirX[l_dir], node->y + DirY[l_dir]);
        bool r_force_ = Walk(node->x + DirX[r_dir], node->y + DirY[r_dir]);

        if( !l_force_ || !r_force_ )
        {//斜线方向有强迫邻居
            l_dir = (dir + 2) % 8;
            r_dir = (dir + 6) % 8;
            if( !l_force_ && Walk(node->x + DirX[l_dir], node->y + DirY[l_dir]) )
            {
                jpsN_ = true;
                return node;
            }

            if( !r_force_ && Walk(node->x + DirX[r_dir], node->y + DirY[r_dir]) )
            {
                jpsN_ = true;
                return node;
            }
        }

        //斜线两个方向是否有跳点
        l_dir = (dir + 1) % 8;
        r_dir = (dir + 7) % 8;

        bool l_force = false;
        bool r_force = false;
        NodePtr l_node = GetNode(node->x + DirX[l_dir], node->y + DirY[l_dir]);

        if( l_node && l_node->dir == -1 )
            Jump(l_node, l_dir);
        l_force = jpsN_;
        
        NodePtr r_node = GetNode(node->x + DirX[r_dir], node->y + DirY[r_dir]);
        if( r_node && r_node->dir == -1 )
            Jump(r_node, r_dir);
        r_force = jpsN_;

        if( l_force || r_force )
        {
            return node;
        }

        NodePtr next_node = GetNode(node->x + DirX[dir], node->y + DirY[dir]);
        if( next_node )
            next_node->dir = dir;
        
        return Jump(next_node, dir);
    }

  1. 直线方向递归

NodePtr JpsFind::JumpStr( const NodePtr& node, int32 dir )
    {
        //直线方向 上下左右
        int32 l_dir = (dir + 2) % 8;
        int32 r_dir = (dir + 6) % 8;
        bool l_force_ = Walk(node->x + DirX[l_dir], node->y + DirY[l_dir]);
        bool r_force_ = Walk(node->x + DirX[r_dir], node->y + DirY[r_dir]);
        
        if( !l_force_ || !r_force_ )
        {
            int32 l_force_dir = (dir + 1) % 8;
            int32 r_force_dir = (dir + 7) % 8;

            bool left_next  = Walk(node->x + DirX[l_force_dir], node->y + DirY[l_force_dir]);
            bool right_next = Walk(node->x + DirX[r_force_dir], node->y + DirY[r_force_dir]);

            if( !l_force_ && left_next )
            {
                jpsN_ = true;
                return node;
            }

            
            if( !r_force_ && right_next )
            {
                jpsN_ = true;
                return node;
            }
        }

        NodePtr next_node = GetNode(node->x + DirX[dir], node->y + DirY[dir]);
        if( next_node )
            next_node->dir = dir;
        
        return Jump(next_node, dir);
    }

完整效果图:

完整跳点图

m0_63608714xj
关注
【全局路径规划模块图搜索算法】jump point search(JPS)跳点搜索算法（附C++代码）
qq_35635374的博客
04-28 740
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对** jump point search(JPS)跳点搜索算法**做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容如果节点n是x的邻居，并且节点n的邻居有阻挡（不可行走的格子），并且从parent(x)、x、n的路径长度比其他任何从parent(x)到n且不经过x的路径短，其中parent(x)为路径中x的前一个点，则n为x的强迫邻居，x为n的跳点。
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...
C++ 实现JPS(完整代码)
m0_63608714的博客
06-26 943
【代码】C++ 实现JPS(完整代码)
路径规划——Jump Point Search算法
最新发布
weixin_51995147的博客
08-20 2904
Jump Point Search (JPS，跳点搜索算法) 是一种优化的路径搜索算法，主要用于加速A*算法在网格图上的搜索过程，特别是在规则网格（如四向或八向网格）上表现出色。JPS通过跳过一些冗余节点，减少了需要扩展的节点数量，从而加速了搜索过程。
ROS下用C++实现A* /JPS算法
ymh博客
07-08 3994
在ROS下用C++实现A* /JPS算法 A* 算法流程 见文件:src/grid_path_searcheer/src/demo_node.cpp 主函数 main 1. int main(int argc, char** argv) 2. { 3. ...... 4. //订阅到地图信息的回调函数 5. _map_sub = nh.subscribe( "map", 6. //订阅到终点信息的回调函数 7. _pts_sub = nh.subscribe( "waypoints", 1, rcvWayp
jps3d:在2D和3D地图上的跳转点搜索的C ++实现
05-10
MRSL跳转点搜索计划库v1.1 跳转点搜索可在2D和3D环境中进行路径规划。 原始跳点搜索算法在。 在提出了3D版本 。 此DMPlanner中还包括距离图计划器（ DMPlanner ）。 DMPlanner会在障碍物周围增加一个人工势场，并在特定区域内规划一条更安全的路径。 后面的部分将介绍更多详细信息。 安装 必需的： 本征3 yaml-cpp 只需运行以下命令来安装依赖项： $ sudo apt update $ sudo apt install -y libeigen3-dev libyaml-cpp-dev libboost-dev cmake A）简单的cmake $ mkdir build && cd build && cmake .. && make -j4 B）使用CATKIN $ mv jps3d ~ /catkin_ws/src $ cd ~ /c
用C ++实现的 RTS 游戏的 路径查找算法（A*、JPS、Wall-tracing）
06-08
带有网格图的 RTS 游戏的路径查找算法的 C++ 实现。 如何使用 此代码用于我的类似 RTS 的游戏中，带有自定义内部引擎。我照原样复制它，没有实现许多类，如 vec2、Array、MemoryManager 等。所以如果有人想使用它，他需要替换它们。 算法适用于最大边尺寸为 2^16 的网格图。如果牢房不可步行，则有一堵墙。也有可能添加任意半径的圆形障碍物。输入地图的边界必须是不可行走的，因为出于优化原因，没有检查坐标是否超出边界。 寻找路径有两个阶段： 粗略 - 关节位置限制在单元格的中心。可以使用 3 种算法之一找到路径：A*、JPS 或 JSP+。Obstables 对结果路径没有影响。 精确 - 使用“墙壁追踪”在连续空间中工作 该方案来自游戏“Dota 2”。首先，您搜索到目标点的粗略路径，然后搜索从当前位置到粗略路径上某个点的精确路径。一段时间后，当到该点的距离变得足够短时，您在粗糙路径上搜索到另一个点的精确路径。
「游戏」寻路算法之JPS原理和实现
_Echo_
03-25 3501
前言 之前的文章讲解了关于寻路算法中常见的算法以及AStar寻路算法的原理以及其实现方式，但是对于AStar寻路算法来说，其也有一定的缺点。 A Star算法的问题在于其在进行节点搜索的时候，会把周围8个方向所有的可用邻居节点全部存储于，这样openlist中点的数量会很多，搜索效率较慢，并且占用内存也会很高。 如图所示，在无遮挡情况下，可能这种情况会有很多条路径， 对于我们来说只需要一条从起点到终点的路径就够了，下图中绿色为放入OpenList中的节点，由图中看出往往这些节点并没有必要放进去，如果我们把
JPS（Jump Point Search）A*跳点搜索
08-16
JPS（Jump Point Search）是一种优化的路径搜索算法，它是A*算法的一种变体，专为网格环境中的路径规划设计。A*算法是广泛应用的最短路径查找算法，以其效率和准确性而闻名。然而，在大型网格地图上，A*算法可能会变...
JPS+(Jump point search plus)寻路算法
lq
03-19 1384
JPS+ 是在 Jps 的基础上对地图进行了预处理，将数据记录在节点上 JPS 是运行时计算节点在某个方向上的跳点 JPS+ 预处理则是将 每个节点每个方向上的跳点、障碍信息记录，在运行时，不需要经过计算，直接获取某个方向上的跳点，节省大量时间和空间，提升计算速度 JPS+ 地图预处理 前提条件 1：地图必须是静态的，预处理时和运行时地图必须是一样的，不对在运行时添加、删除、修改节点状态 2：预处理需要每个节点存储一些数据，对内存占用较大 3：预处理需要时间较长，地图内每个节点都要进行数据处理，时间复杂
JPS算法的python实现及其可视化
08-06
在文件目录启动命令行窗口，输入python Main.py -v map.bmp即可运行
jpsplus+goalbounding寻路算法
10-28
据说被A*快100倍的寻路算法，2015年提出。jps plus是在jps算法基础上对地图做了预处理，记录了一些跳点信息，加快寻找下一个跳点的速度；goalbinding做了另一些预处理，记录一些方向信息，避免往错误方向上寻找跳点。附上一个mfc实现jps+算法的demo
JPS(jump point search)寻路算法
热门推荐
lq
07-16 1万+
JPS(jump point search)寻路算法 JPS（jump point search）跳跃点寻路算法是对AStar寻路算法的一个改进。 AStar 算法在扩展节点时会把所有相邻的节点考虑进去，当地图比较大时，openList 中的节点数量会很多，搜索效率较低。 在两点之间没有障碍物时，那么中间的节点对我们来说是没有用的，不希望添加到 openList 如下 可以看到JPS 算法不是每个节点都紧密连接的，而是跳跃性的或者说只有需要转弯的节点(也叫拐点)才会被考虑，所以叫跳跃点(Jump Poin
C++跳点搜索
auccy的博客
03-07 470
这两天用C++写了个JPS，原理网上有很多介绍，不了解的小伙伴自行搜索即可。 C++版JPS实现：https://github.com/jjinglover/myTools/tree/main/JPS 参考资料：https://zhuanlan.zhihu.com/p/181734749
Jump Point Search(JPS)算法总结与实现（附Demo)
qq_29261149的博客
08-12 4628
关于这篇文章 第一次翻阅A星算法的文章，是为了弄清楚A星在游戏开发中的地位。当是在脑海中没有形成它的算法模型，也苦于没有一个自定义轨迹且又能展示每一步的细节的demo，于是自己动手写了一个测试demo。后来又因为效率的问题接触到了JPS，于是又实现了一版JPS的逻辑，后分别整理成文章发布。 这期间大约经历了一个月时间，这段时间有很多人给我讲，这些内容网上有很多，没必要费那么大的功夫。 但～ 我觉得，做一个领域的研究要有锱铢必较的心态，这才是做程序开发本该有的素养。 从市场的角度来想，这个行业会不断的有新鲜血
c++ A*和JPS算法框架navigation_astar
weixin_48628189的博客
08-09 3696
c++ A*和JPS算法框架navigation_astar 代码在我的码云里面：https://gitee.com/spiderman-spiderman/navigation_astar.git 我将从下面几点介绍我对3DA*代码框架的理解和作业的完成以及遇到的问题和解决过程： 第一、代码框架介绍； 第二、四个重要函数介绍； 第三、遇到的问题和解决过程； 第四、3D栅格图实现的路径规划转变为2D栅格图实现； 第一、代码框架介绍； 代码框架中我认为最难的几个部分如下： 1、初始化地图中的三级指针 Gri
JPS算法
JasonLi的博客
02-25 6137
在A*算法的基础上，推导JPS算法的规则、特点
跳点搜索算法 (JPS算法) && 效率优化(摘录)
丶党玲儿的博客
10-03 8192
摘自:腾讯游戏开发精粹(摘录一次加深记忆方便查找,如有侵权 联系作者删除 谢谢) 如感兴趣,请购买原书支持
jump point search c++
05-13
Jump Point Search（JPS）是一种快速的路径搜索算法，它是对A*算法的优化。在搜索过程中，JPS可以有效地减少搜索的节点数，从而大大提高搜索速度。JPS算法工作原理是首先构建一颗网格图，在该图上进行搜索。当起始点和目标点都在图的节点上时，使用ASTAR算法进行搜索。当起始点或目标点不在图的节点上时，先找到两个最近的节点，然后执行算法。JPS有两个重要操作：跳跃和标志节点。跳跃操作可以直接跳过一些无用的节点，节省搜索时间，并且可以保证找到的路径是最短的。标志节点可以避免在已经搜索过的节点上重复搜索，从而提高效率。JPS算法可以使用于广泛的领域，例如游戏开发、机器人路径规划和数据挖掘等。C语言是一种高效的编程语言，JPS算法也可以使用C语言实现。实现JPS算法需要一定的编程经验和算法理解，但是使用C语言可以得到更高的算法执行效率。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值