A星寻路的平滑处理 c++实现

最新推荐文章于 2024-06-22 14:16:14 发布
最新推荐文章于 2024-06-22 14:16:14 发布
阅读量4.9k 收藏 24
点赞数 3
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36984465/article/details/85833659
版权

RPG游戏离不开寻路 A星寻路是游戏的最短路径寻路算法。

网上有很多A*寻路的源码，我学习了几份，发现它们都没有对路径进行平滑处理，路径都是不平滑的  这样游戏角色寻路走路会很怪异。看到别人博客思路，自己用c++撸一遍 

我的起点为 0，0点 终点为9，6点

思路借鉴：https://blog.csdn.net/m0_37290785/article/details/79655666

//初始化地图数据
    int **map = new int*[10];
    for (int i = 0; i < 10; i++)//为指针数组的每个元素分配一个数组
        map[i] = new int[10];
    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 10; j++)
        {
            map[i][j] = 0;
        }
    }
    map[2][0] = 1;
    map[2][1] = 1;
    map[2][2] = 1;
    map[2][3] = 1;
    map[2][4] = 1;
    map[2][5] = 1;
    map[2][6] = 1;
    map[4][10] = 1;
    map[4][9] = 1;
    map[4][8] = 1;
    map[4][7] = 1;
    map[4][6] = 1;
    map[4][5] = 1;
    map[4][4] = 1;

Astar astar;

astar.setDataByMap(map, 10, 10);

std::vector<MapReader::sVec2> path =astar.findAstart(9, 6,0, 0);

看下图的8是原生的的路径。  

怎么去优化呢。

第一步比较简单删去路径上的共线点  这些共线点已经没有意义了

//1.将路径去掉共线点
    int max = path.size() - 2;
    for (int i = 0; i <max; )
    {
        if ((path[i].x * path[i + 1].y - path[i + 2].y * path[i].x) + (path[i + 1].x * path[i + 2].y - path[i].y * path[i + 1].x) + (path[i + 2].x * path[i].y - path[i + 2].x * path[i + 1].y) == 0)//判断三点共线
        {
            path.erase(path.begin() + i + 1);
            max = path.size() - 2;
        }
        else
        {
            i++;
        }

    }

然后我得出了下图路径 

第二步，去掉多余拐点，这一步复杂一点，需要判断两节点是否能够直达，若能直达五障碍物即可删除二者的中间节点，可以参考https://blog.csdn.net/midashao/article/details/70237061

然后就得到了最终路径

//2.判断是否直达
    cout << "删除多余路径过程" << endl;
    int max1 = path.size() - 2;
    for (int i = 0; i < max1; )
    {
        bool okjudge = true;
        //获取两点之间斜率
        if (path[i].x == path[i + 2].x || path[i].y == path[i + 2].y)
        {
            cout << i << "斜率0或90" << endl;
            i++;
            continue;
        }
        float k = float(path[i + 2].x - path[i].x) / float(path[i + 2].y - path[i].y);
        float b = path[i].x + 0.5 - k * (path[i].y + 0.5);
        cout << i << "斜率K:" << k << " b:" << b << endl;
        if (fabs(k) <= 1)
        {
            if (k > 0 && path[i + 2].y > path[i].y || k<0 && path[i + 2].y > path[i].y)
            {
                cout << "斜率小于等于45度 " << endl;
                //斜率小于45度
                //获取宽度差
                int width = fabs(path[i + 2].y - path[i].y);
                for (int j = 0; j < width; j++)
                {
                    float y = (1 + path[i].y + j) * k + b;
                    cout << y << endl;
                    if (y != int(y))//y不是整数
                    {
                        cout << path[i].y + j << " " << int(y) << "   " << path[i].y + j + 1 << " " << int(y) << endl;
                        cout << "1:   " << g_Map[path[i].y + j][int(y)].iColor << " " << g_Map[path[i].y + j + 1][int(y)].iColor << endl;
                        if (g_Map[path[i].y + j][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[path[i].y + j + 1][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }

            }
            else if (k<0 && path[i + 2].y < path[i].y || k>0 && path[i + 2].y < path[i].y)
            {
                cout << "斜率小于等于45度 " << endl;
                //斜率小于45度
                //获取宽度差
                int width = fabs(path[i + 2].y - path[i].y);
                for (int j = 0; j < width; j++)
                {
                    float y = (0.5 + path[i].y - 0.5 - j) * k + b;
                    cout << y << endl;
                    if (y != int(y))//y不是整数
                    {
                        cout << path[i].y - j << " " << int(y) << "   " << path[i].y - j - 1 << " " << int(y) << endl;
                        cout << "1:   " << g_Map[path[i].y - j][int(y)].iColor << " " << g_Map[path[i].y - j - 1][int(y)].iColor << endl;
                        if (g_Map[path[i].y - j][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[path[i].y - j - 1][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }
            }
        }
        else
        {
            if (k > 0 && path[i + 2].x > path[i].x || k<0 && path[i + 2].x > path[i].x)
            {
                cout << "斜率大于45度" << endl;
                //斜率大于45度
                //获取高度差
                int height = fabs(path[i + 2].x - path[i].x);
                for (int j = 0; j < height; j++)
                {
                    float x = ((0.5 + path[i].x + 0.5 + j) - b) / k;
                    cout << x << endl;
                    if (x != int(x))
                    {
                        cout << int(x) << " " << path[i].x + j << "   " << int(x) << " " << path[i].x + j + 1 << endl;
                        cout << "2:     " << g_Map[int(x)][path[i].x + j].iColor << " " << g_Map[int(x)][path[i].x + j + 1].iColor << endl;
                        if (g_Map[int(x)][path[i].x + j].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[int(x)][path[i].x + j + 1].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }
            }
            else if (k<0 && path[i + 2].x < path[i].x || k>0 && path[i + 2].x < path[i].x)
            {
                cout << "斜率大于45度" << endl;
                int height = fabs(path[i + 2].x - path[i].x);
                for (int j = 0; j < height; j++)
                {
                    float x = ((0.5 + path[i].x - 0.5 - j) - b) / k;
                    cout << x << endl;
                    if (x != int(x))
                    {
                        cout << int(x) << " " << path[i].x - j << "   " << int(x) << " " << path[i].x - j - 1 << endl;
                        cout << "2:     " << g_Map[int(x)][path[i].x - j].iColor << " " << g_Map[int(x)][path[i].x - j - 1].iColor << endl;
                        if (g_Map[int(x)][path[i].x - j].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[int(x)][path[i].x - j - 1].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }
            }

        }
        if (okjudge == false)
        {
            i++;
        }
        else
        {
            cout << "删除节点成功" << endl;
            path.erase(path.begin() + i + 1);
            max1 = path.size() - 2;
        }
    }

 

 

最后将两步封装成寻路的一个成员函数。就可以随时调用了

std::vector<MapReader::sVec2> Astar::pathCreat(std::vector<MapReader::sVec2> path)
{
    //1.将路径去掉共线点
    int max = path.size() - 2;
    for (int i = 0; i <max; )
    {
        if ((path[i].x * path[i + 1].y - path[i + 2].y * path[i].x) + (path[i + 1].x * path[i + 2].y - path[i].y * path[i + 1].x) + (path[i + 2].x * path[i].y - path[i + 2].x * path[i + 1].y) == 0)//判断三点共线
        {
            path.erase(path.begin() + i + 1);
            max = path.size() - 2;
        }
        else
        {
            i++;
        }

    }
    cout << "去掉共线点路径打印" << endl;
    for (int i = 0; i < path.size(); i++)
    {
        cout << "路径" << i << ": " << path[i].y << "," << path[i].x << endl;
    }

    //2.判断是否直达
    cout << "删除多余路径过程" << endl;
    int max1 = path.size() - 2;
    for (int i = 0; i < max1; )
    {
        bool okjudge = true;
        //获取两点之间斜率
        if (path[i].x == path[i + 2].x || path[i].y == path[i + 2].y)
        {
            cout << i << "斜率0或90" << endl;
            i++;
            continue;
        }
        float k = float(path[i + 2].x - path[i].x) / float(path[i + 2].y - path[i].y);
        float b = path[i].x + 0.5 - k * (path[i].y + 0.5);
        cout << i << "斜率K:" << k << " b:" << b << endl;
        if (fabs(k) <= 1)
        {
            if (k > 0 && path[i + 2].y > path[i].y || k<0 && path[i + 2].y > path[i].y)
            {
                cout << "斜率小于等于45度 " << endl;
                //斜率小于45度
                //获取宽度差
                int width = fabs(path[i + 2].y - path[i].y);
                for (int j = 0; j < width; j++)
                {
                    float y = (1 + path[i].y + j) * k + b;
                    cout << y << endl;
                    if (y != int(y))//y不是整数
                    {
                        cout << path[i].y + j << " " << int(y) << "   " << path[i].y + j + 1 << " " << int(y) << endl;
                        cout << "1:   " << g_Map[path[i].y + j][int(y)].iColor << " " << g_Map[path[i].y + j + 1][int(y)].iColor << endl;
                        if (g_Map[path[i].y + j][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[path[i].y + j + 1][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }

            }
            else if (k<0 && path[i + 2].y < path[i].y || k>0 && path[i + 2].y < path[i].y)
            {
                cout << "斜率小于等于45度 " << endl;
                //斜率小于45度
                //获取宽度差
                int width = fabs(path[i + 2].y - path[i].y);
                for (int j = 0; j < width; j++)
                {
                    float y = (0.5 + path[i].y - 0.5 - j) * k + b;
                    cout << y << endl;
                    if (y != int(y))//y不是整数
                    {
                        cout << path[i].y - j << " " << int(y) << "   " << path[i].y - j - 1 << " " << int(y) << endl;
                        cout << "1:   " << g_Map[path[i].y - j][int(y)].iColor << " " << g_Map[path[i].y - j - 1][int(y)].iColor << endl;
                        if (g_Map[path[i].y - j][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[path[i].y - j - 1][int(y)].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }
            }
        }
        else
        {
            if (k > 0 && path[i + 2].x > path[i].x || k<0 && path[i + 2].x > path[i].x)
            {
                cout << "斜率大于45度" << endl;
                //斜率大于45度
                //获取高度差
                int height = fabs(path[i + 2].x - path[i].x);
                for (int j = 0; j < height; j++)
                {
                    float x = ((0.5 + path[i].x + 0.5 + j) - b) / k;
                    cout << x << endl;
                    if (x != int(x))
                    {
                        cout << int(x) << " " << path[i].x + j << "   " << int(x) << " " << path[i].x + j + 1 << endl;
                        cout << "2:     " << g_Map[int(x)][path[i].x + j].iColor << " " << g_Map[int(x)][path[i].x + j + 1].iColor << endl;
                        if (g_Map[int(x)][path[i].x + j].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[int(x)][path[i].x + j + 1].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }
            }
            else if (k<0 && path[i + 2].x < path[i].x || k>0 && path[i + 2].x < path[i].x)
            {
                cout << "斜率大于45度" << endl;
                int height = fabs(path[i + 2].x - path[i].x);
                for (int j = 0; j < height; j++)
                {
                    float x = ((0.5 + path[i].x - 0.5 - j) - b) / k;
                    cout << x << endl;
                    if (x != int(x))
                    {
                        cout << int(x) << " " << path[i].x - j << "   " << int(x) << " " << path[i].x - j - 1 << endl;
                        cout << "2:     " << g_Map[int(x)][path[i].x - j].iColor << " " << g_Map[int(x)][path[i].x - j - 1].iColor << endl;
                        if (g_Map[int(x)][path[i].x - j].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }
                        if (g_Map[int(x)][path[i].x - j - 1].iColor == true)
                        {
                            okjudge = false;
                            break;
                        }

                    }
                    else
                    {

                    }
                }
            }

        }
        if (okjudge == false)
        {
            i++;
        }
        else
        {
            cout << "删除节点成功" << endl;
            path.erase(path.begin() + i + 1);
            max1 = path.size() - 2;
        }
    }
    return path;
}

 使用只需要包裹下就ok了

    Astar astar;
    astar.setDataByMap(map, 10, 10);
    std::vector<MapReader::sVec2> path = astar.pathCreat(astar.findAstart(9, 6,0, 0));

当然我的代码还存在一定的缺陷= =。忘大佬评论指出不足之处。

 

关无痕
关注
  • 3
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
【C++】ROS：AStar规划算法原理与实现
DevFrank的博客
08-09 1640
AStar规划算法原理与实现
三维山地图+A星算法+B样条平滑
12-04
对10*10的二维高程矩阵进行插值，得到较平滑的三维山地图，使用A星算法得到起点到终点的最优路径，使用B样条插值法对路径进行平滑处理。
《寻路算法》A*寻路的路径平滑、静态合并、生成格子工具自动化的思路
06-14 742
提纲： 1.平滑A型算法的路径   2.A*算法的格子静态合并、优化A*算法的寻路性能  3. A*寻路向navmesh寻路的演进（navmes设计思路） 4.A*工具化 平滑A型算法的路径   如图1   我使用一种简单的情况来说明，假设在地图上寻路，如果从A点（灰色格子）寻到X点，那么使用普通A*算法寻路出来可能是这样的 现在格子很不规则，我们想使路径平滑，一般采用的
A*算法仿真及改进：提升搜索效率、冗余拐角优化、路径平滑处理（含Matlab代码和固定栅格地图），路径规划算法仿真：传统与改进的A*算法在Matlab中的比较与优化
最新发布
WJWmjbhdcjt的博客
06-22 404
梯度下降算法能够根据地图的梯度信息对路径进行平滑处理，从而使得路径在不改变起点和终点的情况下更加平缓。为了优化路径的拐角，我们提出了冗余拐角优化策略，并在改进后的A*算法中加以应用。通过本文的阐述，读者可以了解到路径规划算法的重要性和应用场景，以及传统A。算法的原理和实现方式，同时可以通过比较两者的性能来选择适合自己需求的路径规划算法。算法的有效性，我们提供了包含注释的Matlab代码，并可固定栅格地图、起点和终点进行定量比较。算法的代码进行确认，然后再运行改进后的A*算法进行比较和评估。
A*寻路之路径平滑（二）
u014028063的博客
07-05 1万+
背景：在上一篇文章路径优化中对于A*传统寻路的结果不平滑的问题，为了解决生成折线Z型路线，我们尝试了一种判断两点间是否存在障碍物的算法，并在生成寻路路径时候先判断起终点间是否存在障碍物，若不存在障碍物，则路径数组中将只具有一个终点节点；否则调用A*寻路运算。大致过程可用下面代码表示：//判断起终点间是否存在障碍物，若存在则调用A*算法进行寻路，通过A*寻路得到的路径是一个个所要经过的节点数组；否不...
寻路算法的平滑处理
~。~|||
08-11 6247
AA
c++ A星算法
jiletianzun的博客
05-27 233
/* 作者：逍遥天尊 时间：2022-5-27 描述：图形界面版本的A星算法 运行没有界面，原因是没有图，你需要三张图大小为50，50.图片需要放在源代码文件同级目录 图片和源码文件连接附上：链接：https://pan.baidu.com/s/1eOkb1p3FI8sXEkwz2nAwUQ 提取码：rzcb --来自百度网盘超级会员V6的分享 */ #include<stdlib.h> #include<stdio.h> #include<vector&gt.
A星算法C++实现
09-23
C++实现的A*寻路算法，经过测试，在有障碍物的情况下，路径为期望路径，内附测试结果，可以修改地图的大小及障碍物位置，比如大小改为1920*1080，使其更接近真实电脑屏幕或者手机屏幕分辨率，得到更为贴近实际的运算效率
c++游戏开发 AStar A星寻路算法.zip
01-23
在C++中实现A星寻路算法，需要对数据结构（如队列和图）有深入理解，同时熟悉面向对象编程，以便将算法逻辑封装成易于理解和维护的类。通过实践和调试，开发者可以不断优化算法，使其适应不同类型的游戏场景，提供更...
A星寻路路径优化示例程序
09-26
在MFC（Microsoft Foundation Classes）环境中实现A星寻路，可以利用C++的面向对象特性，为地图、节点、边等对象定义类，并实现相应的操作。MFC是一个C++库，用于构建Windows应用程序，提供了一套丰富的用户界面控件...
ROS中使用A星算法进行路径规划
热门推荐
a819096127的博客
04-26 1万+
ROS中使用A星算法进行路径规划前言python编写A星算法描述具体实现ROS结合A星算法描述具体实现实现结果 前言 由于本人这学期修了一门《智能工程》的课程，课程的大作业要求大家自主编写机器人导航程序，包括：路径规划、轨迹规划、控制器、机器人建模等相关程序，因此特在此写下一篇博客，记录开发过程。 这是第一篇博客，用于记录如何将自己编写的A星算法用于ROS中。 python编写A星算法 描述 先声...
C++、A星算法(很不错)
08-22
内有N个范例，每个都可以使用，算法使用图形表示。上手容易。
A星寻路算法c++语言实现
07-27
A*算法，A*（A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。c++语言实现
C++平滑滤波
10-27
利用c++编写的平滑滤波函数，函数可以快速实现平滑滤波。通过控制滤波窗口大小，来改变滤波效果
cocos2dx 3.0 A星算法
05-26
在游戏开发中，特别是使用Cocos2dx这样的2D游戏引擎时，A星算法是实现角色自动寻路的关键技术。Cocos2dx 3.0版本支持跨平台开发，包括iOS和Android，但需要注意的是，iOS和Android平台之间可能存在一些差异，如在...
A_Star算法C++实现
gdc6916的博客
09-19 2285
hello！
A星(A* or A star)算法C++实现及opencv可视化
tanjia6999的博客
04-16 4186
A*算法，具体原理可参看已有的博客，下面是我觉得比较好的几个。A*，那个传说中的算法堪称最好的A*算法自己在github上找到了一个比较简单的用C++实现的版本(点击打开链接)，自己在此基础上添加了opencv绘制简单图块，将结果可视化了，如下图。其中，红色为障碍块，白色绿边为自由空间，蓝色为起始点，黑色为目标点，规划的路径用黄色块表示，程序设定可斜对角穿行。#include &lt;iostre...
A星算法(游戏寻路算法)的C++实现
笨笨D幸福 - 后花园
04-26 1万+
先吐槽一句：CODE功能太不给力了，怎么弄怎么崩溃，
C++A星寻路代码
05-24
以下是一个简单的C++ A星寻路代码实现： ```cpp #include <iostream> #include <queue> #include <vector> #include <cmath> using namespace std; const int INF = 1e9; // 无穷大 const int MAXN = 1005; // 最大节点数 struct Node { int x, y; // 坐标 int g, h; // 距离起点的代价g和距离终点的代价h int f() const { // 总代价f return g + h; } }; int n, m; // 地图大小 char map[MAXN][MAXN]; // 地图 Node start, end; // 起点和终点 int vis[MAXN][MAXN]; // 是否访问过 // 估算距离函数，这里取曼哈顿距离 int estimate(int x1, int y1, int x2, int y2) { return abs(x1 - x2) + abs(y1 - y2); } // A*搜索函数 int astar() { priority_queue<pair<int, Node>> Q; // 优先队列 Q.push(make_pair(0, start)); while (!Q.empty()) { Node u = Q.top().second; Q.pop(); if (u.x == end.x && u.y == end.y) { // 找到终点 return u.g; } if (vis[u.x][u.y]) { // 已经访问过，跳过 continue; } vis[u.x][u.y] = 1; // 标记为已访问 // 枚举相邻节点 for (int dx = -1; dx <= 1; dx++) { for (int dy = -1; dy <= 1; dy++) { if (dx == 0 && dy == 0) { continue; } int nx = u.x + dx, ny = u.y + dy; if (nx < 0 || nx >= n || ny < 0 || ny >= m) { continue; // 超出边界 } if (map[nx][ny] == '#') { continue; // 障碍物 } Node v = {nx, ny, u.g + 1, estimate(nx, ny, end.x, end.y)}; Q.push(make_pair(-v.f(), v)); // 插入队列，优先级为f的相反数 } } } return -1; // 没有找到路径 } int main() { cin >> n >> m; for (int i = 0; i < n; i++) { cin >> map[i]; for (int j = 0; j < m; j++) { if (map[i][j] == 'S') { start = {i, j, 0, 0}; } if (map[i][j] == 'E') { end = {i, j, 0, 0}; } } } int ans = astar(); if (ans == -1) { cout << "No path found." << endl; } else { cout << "The shortest path is " << ans << "." << endl; } return 0; } ``` 该代码实现了一个简单的A星寻路算法，包括估算距离函数、A星搜索函数和主函数。其中使用了STL的priority_queue来实现优先队列。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值