精华内容
下载资源
问答
  • 2. 绝对轨迹误差(ATE) 直接计算相机位姿的真实值与SLAM系统的估计值之间的差值,首先将真实值与估计值的时间戳对齐,然后计算每对位姿之间的差值,适合于评估SLAM系统的性能。 参考链接:参考文章 ...

    1. 相对位姿误差(RPE)

    用于计算两个相同时间戳上相机位姿的真实值与SLAM系统的估计值之间每隔一段时间位姿变化量之间的差值,也可以理解为位姿真实值与与估计值的实时比较。该标准适合于估计系统的漂移。

    2. 绝对轨迹误差(ATE)

    直接计算相机位姿的真实值与SLAM系统的估计值之间的差值,首先将真实值与估计值的时间戳对齐,然后计算每对位姿之间的差值,适合于评估SLAM系统的性能。

    参考链接:参考文章

    展开全文
  • 绝对轨迹误差直接计算相机位姿的真实值与SLAM系统的估计值之间的差,程序首先根据位姿的时间戳将真实值和估计值进行对齐, 然后计算每对位姿之间的差值, 并最终以图表的形 式输出, 该标准非常适合于评估视觉 SLAM ...

    绝对轨迹误差直接计算相机位姿的真实值与SLAM系统的估计值之间的差,程序首先根据位姿的时间戳将真实值和估计值进行对齐, 然后计算每对位姿之间的差值, 并最终以图表的形
    式输出, 该标准非常适合于评估视觉 SLAM 系统的性能。

    相对位姿误差用于计算相同两个时间戳上的位姿变化量的差, 同样, 在用时间戳对齐之后, 真实位姿和估计位姿均每隔一段相同时间计算位姿的变化量, 然后对该变化量做差, 以获得相对位姿误差, 该标准适合于估计系统的漂移。

    展开全文
  • 常用评估轨迹误差的方式有两种:绝对轨迹误差(ATE)与相对轨迹误差(RPE) 1.绝对轨迹误差(Absolute Trajectory Error, ATE) 绝对轨迹误差即为求每个位姿李代数的均方根 如图,有两条轨迹,一条为真实轨迹esti...

    目录

    1.绝对轨迹误差(Absolute Trajectory Error, ATE)

     1.1旋转+平移的均方根误差

    1.2 仅计算平移的均方根误差

    2.相对轨迹误差(Relative Pose Error, RPE)

     2.1旋转+平移的均方根误差

     2.2平移的均方根误差 

    3.代码部分

    4.evo工具

    4.1 evo工具安装以及使用说明

    4.2 evo中计算ATE(APE)

    4.2 evo中计算RPE


    常用评估轨迹误差的方式有两种:绝对轨迹误差(ATE)与相对轨迹误差(RPE)

    1.绝对轨迹误差(Absolute Trajectory Error, ATE)

    绝对轨迹误差即为求每个位姿李代数的均方根

    如图,有两条轨迹,一条为真实轨迹esti,一条为slam算法估算的轨迹gt, 将两条轨迹分为无数个点,并在上面分别取两个点Pesti,i和Pg,i,其相对于原点P的计算公式如下,其中T为欧式变化(属于李群

    P_{esti,i} = T_{esti,i}*P

     P_{g,i} = T_{g,i}*P

    计算第i个点的误差error的李群形式,写成相除的形式比较好理解:

    error = P_{esti,i} / P_{g,i} = T_{esti,i} * T_{g,i}^{-1}

     1.1旋转+平移的均方根误差

    由于我们最终求的是李代数的均方根,所以先求error对应的李代数,提出一个负号(可在代码中验证)

    E_{g,i} =log_e(T_{g,i+\Delta } * T_{g.i}^{-1})^V = - log_e(T_{g.i}^{-1} *T_{g,i+\Delta })^V

    取范数后,取均方根得到ATEall,取范数后正负号不影响

    ATE_{all} =\sqrt{\frac{1}{N}\sum_{i=1}^N||log_e(T_{g,i} ^{-1} *T_{esti,i})^V||_{2}^{2}}

    1.2 仅计算平移的均方根误差

    在获取平移的均方根时,不需要转换到李代数,在欧式变换(李群)中取出其平移量计算均方根。

    ATE_{all} =\sqrt{\frac{1}{N}\sum_{i=1}^N||trans(T_{g,i} ^{-1} *T_{esti,i})||_{2}^{2}}

    2.相对轨迹误差(Relative Pose Error, RPE)

     2.1旋转+平移的均方根误差

    相对轨迹误差是计算相隔\Delta t时间的两帧之间位姿之差的精度。(有点绕)

     (\Delta t时间对应可能不止1帧,但是是帧数的整数比如1,2,3...帧)

    还是一样,两条轨迹分别为真实轨迹gi,算法估计轨迹esti,这次需要在上面取两个点,对于任意的i点有相应后的i+\Delta点,两条轨迹上的四个点分别记为P_{g,i} ,P_{g,i+\Delta}, P_{esti,i}, P_{esti,i+\Delta }

     与ATE不同的是,RPE是分别计算每条轨迹上两个时刻(也就是两个点)的变化,再求这两个变化的误差。

    分别求真实轨迹gi和算法估计轨迹esti的变化,还是用李代数表示:

    真实轨迹上两帧之间的变化的李代数:

    E_{g,i} =log_e(T_{g,i+\Delta } / T_{g.i})^V = log_e(T_{g,i+\Delta } * T_{g.i}^{-1})^V = - log_e(T_{g.i}^{-1} *T_{g,i+\Delta })^V

    算法估计轨迹上两帧之间的变化的李代数:

    E_{esti,i} =log_e(T_{esti,i+\Delta } * T_{esti.i}^{-1})^V = - log_e(T_{esti.i}^{-1} *T_{esti,i+\Delta })^V

    最后在计算两帧之间变化的误差:

    E_i = log_e(E_{esti,i} / E_{g,i}) = log_e(E_{esti,i}*E_{g,i}^{-1}) = -log_e(E_{g,i}^{-1}*E_{esti,i})

     最后取均方根得到RPEall,注意是之前说的\Delta t对应的是整数帧数,取均方根的时候取到N-\Delta t

    RPE_{all}=\sqrt{\frac{1}{N-\Delta t}\sum _{i=1}^{N-\Delta t}||log_e((T_{gi.i}^{-1} *T_{gi,i+\Delta })^{-1}(T_{esti.i}^{-1} *T_{esti,i+\Delta })^V||_{2}^2}

     2.2平移的均方根误差 

    在获取平移的均方根时,不需要转换到李代数,在欧式变换(李群)中取出其平移量计算均方根。

    RPE_{trans}=\sqrt{\frac{1}{N-\Delta t}\sum _{i=1}^{N-\Delta t}||trans((T_{gi.i}^{-1} *T_{gi,i+\Delta })^{-1}(T_{esti.i}^{-1} *T_{esti,i+\Delta })||_{2}^2}

    3.代码部分

    这部分引用高博《视觉slam14讲》ch4/example中的数据groundtruth.txt和estimated.txt(https://github.com/gaoxiang12/slambook2

    #include<pangolin/pangolin.h>
    #include <iostream>
    #include <sophus/se3.hpp>
    #include <fstream>
    #include <unistd.h>
    #include <Eigen/Core>
    #include <Eigen/Dense>
    
    using namespace std;
    using namespace Sophus;
    using namespace Eigen;
    
    string groundtruth_file = "/home/liao/workspace/slambook2/ch4/example/groundtruth.txt";
    string estimated_file = "/home/liao/workspace/slambook2/ch4/example/estimated.txt";
    
    typedef vector<Sophus::SE3d, Eigen::aligned_allocator<Sophus::SE3d>> TrajectoryType;
    
    TrajectoryType ReadTrajectory(const string& file_name);
    void DrawTrajectory(const TrajectoryType& gt, const TrajectoryType& esti);
    vector<double> calculateATE(const TrajectoryType& gt, const TrajectoryType& esti);
    vector<double> calculateRPE(const TrajectoryType& gt, const TrajectoryType& esti);
    
    int main(int argc, char **argv)
    {
        //读取高博slam14讲中的groundtruth.txt和estimated.txt的数据
        auto gi = ReadTrajectory(groundtruth_file);
        cout << "gi read total " << gi.size() << endl;
        auto esti = ReadTrajectory(estimated_file);
        cout << "esti read total " << esti.size() << endl;
    
        vector<double> ATE, RPE;
        ATE = calculateATE(gi, esti); //计算ATE
        RPE = calculateRPE(gi, esti); //计算RPE
    //    DrawTrajectory(gi, esti);
        return 0;
    }
    vector<double> calculateATE(const TrajectoryType& gt, const TrajectoryType& esti)
    {
        double rmse_all, rmse_trans;
        for(size_t i = 0; i < gt.size(); i++)
        {
            //ATE旋转+平移
            double error_all = (gt[i].inverse()*esti[i]).log().norm();
            rmse_all += error_all * error_all;
            //ATE平移
            double error_trans = (gt[i].inverse()*esti[i]).translation().norm();
            rmse_trans += error_trans * error_trans;
        }
        rmse_all = sqrt(rmse_all / double(gt.size()));
        rmse_trans = sqrt(rmse_trans / double(gt.size()));
        vector<double> ATE;
        ATE.push_back(rmse_all);
        ATE.push_back(rmse_trans);
        cout << "ATE_all = " << rmse_all << " ATE_trans = " << rmse_trans << endl;
    }
    vector<double> calculateRPE(const TrajectoryType& gt, const TrajectoryType& esti)
    {
        double rmse_all, rmse_trans;
        double delta = 1;               //delta = 2, 间隔两帧
        for(size_t i = 0; i < gt.size() - delta; i++)
        {
            //RPE旋转+平移
            double error_all = ((gt[i].inverse()*gt[i + delta]).inverse()*(esti[i].inverse()*esti[i + delta])).log().norm();
            rmse_all += error_all * error_all;
            //RPE平移
            double error_trans = ((gt[i].inverse()*gt[i + delta]).inverse()*(esti[i].inverse()*esti[i + delta])).translation().norm();
            rmse_trans += error_trans * error_trans;
        }
        rmse_all = sqrt(rmse_all / double(gt.size()));
        rmse_trans = sqrt(rmse_trans / double(gt.size()));
        vector<double> RPE;
        RPE.push_back(rmse_all);
        RPE.push_back(rmse_trans);
        cout << "RPE_all = " << rmse_all << " RPE_trans = " << rmse_trans << endl;
    }
    TrajectoryType ReadTrajectory(const string& file_name)
    {
        ifstream fin(file_name);
        TrajectoryType trajectory;
        if(!fin)
        {
            cerr << "trajectory " << file_name << "not found" << endl;
            return trajectory;
        }
        while(!fin.eof())
        {
            double time, tx, ty, tz, qx, qy, qz, qw;
            fin >> time >> tx >> ty >> tz >> qx >> qy >> qz >> qw;
            Sophus::SE3d p1(Eigen::Quaterniond(qw, qx, qy, qz), Eigen::Vector3d(tx, ty, tz));
            trajectory.push_back(p1);
        }
        return trajectory;
    }
    //结果如下:
    
    gi read total 612
    esti read total 612
    ATE_all = 2.20728 ATE_trans = 0.0231005
    RPE_all = 0.0593723 RPE_trans = 0.0310044

    轨迹如图,绿色的为真实轨迹,蓝色为估算轨迹。

    4.evo工具

    4.1 evo工具安装以及使用说明

    安装参考这个帖子:https://www.guyuehome.com/18717

    evo使用看这个帖子:https://blog.csdn.net/dcq1609931832/article/details/102465071

    4.2 evo中计算ATE(APE)

    evo中把ATE称为APE。

    高博书中的格式是数据集TUM格式,即time, tx, ty, tz, qx, qy, qz, qw

    evo中默认计算平移部分,需要通过输入-r full来改为计算平移+旋转。

     分别输入以下命令:

    计算旋转+平移:rmse = 2.397755, 自己写的是ATE_all = 2.20728

    evo_ape tum -r full groundtruth.txt estimated.txt 
    
    #############output################
    
           max	2.828949
          mean	2.353747
        median	2.527603
           min	0.993047
          rmse	2.397755
           sse	3507.030550
           std	0.457280
    

    计算平移:rmse = 0.023082,自己写的是ATE_trans = 0.0231005

    evo_ape tum groundtruth.txt estimated.txt 
    
    #########output###########
    
           max	0.063891
          mean	0.019498
        median	0.016376
           min	0.001271
          rmse	0.023082
           sse	0.325000
           std	0.012354

    4.2 evo中计算RPE

    默认为delta = 1的情况,如需更改为delta = 2,则: -r --delta 2,如下:

    evo_rpe tum -r full --delta 2 groundtruth.txt estimated.txt

    当delta = 1时,分别输入以下命令:

    计算旋转+平移:rmse = 0.078218,RPE_all = 0.0593723

    evo_rpe tum -r full groundtruth.txt estimated.txt 
    
    #############output################
    
    for delta = 1 (frames) using consecutive pairs
    (not aligned)
    
           max	0.314840
          mean	0.067958
        median	0.063364
           min	0.005507
          rmse	0.078218
           sse	3.725902
           std	0.038726
    
    

    计算平移:rmse = 0.031082, 自己写的是:RPE_trans = 0.0310044

    evo_rpe tum groundtruth.txt estimated.txt
    
    ##############output###############
    
    for delta = 1 (frames) using consecutive pairs
    (not aligned)
    
           max	0.115223
          mean	0.025923
        median	0.022008
           min	0.000927
          rmse	0.031082
           sse	0.588337
           std	0.017148
    
    

    最后,对比自己写的和evo算得还是有一点点差别。算旋转的时候会差0.1-0.2,算平移的时候比较准一点。

    展开全文
  • 绝对轨迹误差(Absolute Trahextiry,ATE) 姿态的真实值与姿态的理想值之间的差,实际上是李代数的均方根误差(Root-Mean-Aquared,RMSE) 绝对平移误差(Average Translational Error) 平移部分真实值与姿态的理想...

    注:SLAM十四将的实例

    绝对轨迹误差(Absolute Trahextiry,ATE)

    姿态的真实值与姿态的理想值之间的差,实际上是李代数的均方根误差(Root-Mean-Aquared,RMSE)
    A T E a l l = 1 N ∑ i = 1 N ∣ ∣ l o g ( T g t , i − 1 T e s t i , i ⋁ ) ∣ ∣ 2 2 ATE_{all}=\sqrt{\frac{1}{N}\sum_{i=1}^{N}||log(T^{-1}_{gt,i}T_{esti,i}^{\bigvee})||_2^2} ATEall=N1i=1Nlog(Tgt,i1Testi,i)22

    绝对平移误差(Average Translational Error)

    A T E t r a n s = 1 N ∑ i = 1 N ∣ ∣ t r a n s ( T g t , i − 1 T e s t i , i ⋁ ) ∣ ∣ 2 2 ATE_{trans}=\sqrt{\frac{1}{N}\sum_{i=1}^{N}||trans(T^{-1}_{gt,i}T_{esti,i}^{\bigvee})||_2^2} ATEtrans=N1i=1Ntrans(Tgt,i1Testi,i)22

    相对位姿误差(Average Translational Error)

    A T E t r a n s = 1 N − Δ t ∑ i = 1 N ∣ ∣ l o g ( T g t , i − 1 T g t , i + Δ t ⋁ ) − 1 ( T e s t i , i − 1 T e s t i , i + Δ t ⋁ ) ∣ ∣ 2 2 ATE_{trans}=\sqrt{\frac{1}{N-\Delta t}\sum_{i=1}^{N}||log(T^{-1}_{gt,i}T_{gt,i+\Delta t}^{\bigvee})^{-1}(T^{-1}_{esti,i}T_{esti,i+\Delta t}^{\bigvee})^{}||_2^2} ATEtrans=NΔt1i=1Nlog(Tgt,i1Tgt,i+Δt)1(Testi,i1Testi,i+Δt)22
    平移部分真实值与姿态的理想值之间的差
    实现:

    
    #include <Eigen/Core>
    #include <Eigen/Dense>
    #include <Eigen/Geometry>
    #include <sophus/geometry.hpp>
    #include <sophus/se3.hpp>
    #include <sophus/so3.hpp>
    #include <iostream>
    #include <fstream>
    #include <cmath>
    
    #include <pangolin/pangolin.h>
    using namespace std;
    using namespace Eigen;
    using namespace Sophus;
    typedef vector<Sophus::SE3d,Eigen::aligned_allocator<Sophus::SE3d >> TrajectoryType;
    
    TrajectoryType read_data(string path, vector<double> &Time);
    void plot_jectory( TrajectoryType true_pose,const TrajectoryType pose);
    int main(int argc,char **argv)
    {
      TrajectoryType data,real_data;
      vector<double> Time_data,Time_real_data;
      // Sophus::SE3d p1,p2;
      data=read_data("/home/n1/notes/Sophus/trajectroyError/estimated.txt",Time_data);
      real_data=read_data("/home/n1/notes/Sophus/trajectroyError/groundtruth.txt",Time_real_data);
      cout<<Time_data[0]<<endl;
      cout<<real_data[0].matrix()<<endl;
    
      assert(!real_data.empty() && !data.empty());//如果数据为空终止程序执行
      assert(real_data.size() == data.size());//如果数据长度不相同终止程序执行
      double error[3]={0,0,0};
      double error_sum[3]={0,0,0};
      double rmse=0;//绝对轨迹误差
      double ATE=0;//绝对平移误差
      double RPE=0;//相对时间误差 10s内
      double Delta=0;//变化时间
      double Delta_length=0;//固定时间内数据长度
      for(size_t t=0;t<real_data.size();t++)//计算误差
      {
        Sophus::SE3d p2=real_data[t];
        Sophus::SE3d p1=data[t];
        error[0]=(p2.inverse()*p1).log().norm();//norm() 范数
        error[1]=(p2.inverse()*p1).translation().norm();//平移部分
       
        error_sum[0]+=error[0]*error[0];
        error_sum[1]+=error[1]*error[1];
        Delta=double(Time_data[t]-Time_data[0]);
        
        if(Delta<10)//10s内的相对位姿误差
        {
          p2=real_data[t].inverse()*real_data[t+1];
          p1=data[t].inverse()*data[t+1];
          error[2]+=(p2.inverse()*p1).log().norm();
          error_sum[2]+=error[2]*error[2];
          cout<<"error[2]:"<<error[2]<<endl;
          Delta_length++;
        }
      }
      
      rmse=double(sqrt(error_sum[0]/real_data.size()));
      ATE=double(sqrt(error_sum[1]/real_data.size()));
      RPE=double(sqrt(error_sum[2]/Delta_length));
      cout<<"RMSE:"<<rmse<<endl;
      cout<<"ATE:"<<ATE<<endl;
      cout<<"RPE:"<<RPE<<endl;
      plot_jectory(real_data,data);
    
      return 0;
    }
    
    
    
    
    
    //读取数据函数
    TrajectoryType read_data(string path, vector<double> &Time)
    {
      ifstream fin(path);
      TrajectoryType ject;
      if(!fin)
      {
        cout<<"error"<<endl;return ject;
      }
      double time,tx,ty,tz,qx,qy,qz,qw;
      while (!fin.eof())//处理读取到的数据
      {
        fin>>time>>tx>>ty>>tz>>qx>>qy>>qz>>qw;//重定向数据到
        //cout<<"time"<<time<<endl;
    
        Sophus::SE3d p1(Eigen::Quaterniond(qx,qy,qz,qw),Vector3d(tx,ty,tz));//组成一个SE 欧氏旋转群
        Time.push_back(time);
        ject.push_back(p1);//保存数据点
      }
      cout<<"time"<<Time[0]<<endl;
      return ject;
    }
    
    //绘制点函数
    void plot_jectory(TrajectoryType true_pose, TrajectoryType pose)
    {
      int w=1024,h=768;
      pangolin::CreateWindowAndBind("Display",w,h);//创建名称,大小
      
      glEnable(GL_DEPTH_TEST);//景深
      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);//开启颜色混合
      pangolin::OpenGlRenderState s_cam(//相机参数初始化
          pangolin::ProjectionMatrix(w, h, w/2, h/2, w/2, h/2, 0.1, 1000),
          pangolin::ModelViewLookAt(0, -0.1, -1.8, 0, 0, 0, 0.0, -1.0, 0.0)
      );
    
     
      pangolin::View &d_cam = pangolin::CreateDisplay()
          .SetBounds(0.0, 1.0, pangolin::Attach::Pix(175), 1.0, -float(w/h))
          .SetHandler(new pangolin::Handler3D(s_cam));//创建显示界面
      while (!pangolin::ShouldQuit())
      {
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
        d_cam.Activate(s_cam);
        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        
        for(int i=0;i<true_pose.size()-1;i++)//读取点数据,画直线
        {
          glColor3f(0,0,1);
          
          glBegin(GL_LINES);
          auto p1 = true_pose[i], p2 = true_pose[i + 1];
    
          glVertex3d(p1.translation()[0], p1.translation()[1], p1.translation()[2]);
          glVertex3d(p2.translation()[0], p2.translation()[1], p2.translation()[2]);
          glEnd();
        }
            for(size_t i=0;i<pose.size()-1;i++)//读取点数据,画直线
        {
          glColor3f(0,1,0);
          glBegin(GL_LINES);
          glVertex3f(pose[i].translation()[0],pose[i].translation()[1],pose[i].translation()[2]);
          glVertex3f(pose[i+1].translation()[0],pose[i+1].translation()[1],pose[i+1].translation()[2]);
          glEnd();
        }
        pangolin::FinishFrame();
        
      }
      
    }
    
    
    展开全文
  • slam 轨迹误差
  • 同时利用pangolin/OpenGL画出真实和估计轨迹 注:要用到Eigen、pangolin、Sophus,请提前装好 源码如下: // // //该程序演示了绝对轨迹误差 #include #include #include #include "pangolin/pangolin.h" #include ...
  • SLAM轨迹评估ATE和RPE

    2021-05-08 10:12:29
    1. RPE: relative pose error 相对位姿误差 相对位姿误差主要描述的是相隔固定时间差两帧位姿差的精度(相比真实位姿),相当于直接测量里程计的误差。...绝对轨迹误差是估计位姿和真实位姿的直接差值,可以非...
  • file和string estimated_file的路径修改成绝对路径 #include #include #include #include #include using namespace Sophus; using namespace std; string groundtruth_file = "/home/yu/slam_learn/slambook2-...
  • 经过前面的铺垫下面才是真正的大boos ATE:absolute trajectory error 绝对轨迹误差 绝对轨迹误差直接计算相机位姿的真实值与SLAM系统的估计值之间的差,可以非常直观地反应算法精度和轨迹全局一致性。 需要注意的...
  • 常用的误差度量:绝对轨迹误差(ATE)和相对/测距误差(RE) 相对误差的实现方式与相同,因为它是使用最广泛的版本。 由于轨迹评估涉及许多细节,因此该工具箱的设计易于使用。 它可用于分析,以及使用一个命令...
  • 3. ATE: absolute trajectory error 绝对轨迹误差 4. 工具:EVO 4.1 安装 4.2 usage 1. 轨迹可视化 2. APE 3. RPE 4.3 metrics解析 视觉SLAM基础:算法精度评价指标(ATE、RPE) 1. 前言 当我们需要评估...
  • evo在视觉SLAM中是一个极为有用的工具,对于论文党、科研党、工程党都非常有帮助,它可以用于评估SLAM输出的轨迹的精度,可以自动生成均值、方差、轨迹等等信息的图或者表,总之评估SLAM精度用它足以。    它目前...
  • SLAM 轨迹评估工具EVO

    万次阅读 2020-06-17 09:44:36
    EVO使用教程1 EVO环境安装1.1 二进制安装1.2 源码安装2 使用方法2.1 EUROC数据集上使用2.1.1 计算轨迹绝对误差2.1.2 绘制多条曲线2.1.3 分析多条曲线2.2 KITTI数据集上使用2.2.1 计算轨迹绝对误差2.2.2 绘制多条...
  • 一种SLAM精度评定工具——EVO使用方法详解

    千次阅读 多人点赞 2019-10-09 16:45:04
    绝对位姿误差,常被用作绝对轨迹误差,比较估计轨迹和参考轨迹并计算整个轨迹的统计数据,适用于测试轨迹的全局一致性。 命令语法:命令 格式 参考轨迹 估计轨迹 [可选项] 其中格式包括euroc、tum等数据格式,可选项...
  • SLAM精度评定工具EVO使用方法详解

    千次阅读 2020-08-29 21:38:14
    绝对位姿误差,常被用作绝对轨迹误差,比较估计轨迹和参考轨迹并计算整个轨迹的统计数据,适用于测试轨迹的全局一致性。 命令语法:命令 格式 参考轨迹 估计轨迹 [可选项] 其中格式包括euroc、tum等数据格式,可选项...
  • 在横向轨迹拟合方面,本文以平均绝对误差(MAE )、平均平方根误差(RMSE)和平均相对平方根误差(RMSRE)为指标,探索多项式拟合。研究表明,向左、向右自由换道的横向轨迹和向右强制换道的横向轨迹适宜用 5 次...
  • 单目下运行ORB-SLAM2并使用evo工具评估TUM/KITTI/EuRoC数据集1 算法评价指标(1)系统性能评估-绝对轨迹误差(ATE)(2)系统漂移评估-相对轨迹误差(RPE)(3)精度统计量-均方根误差(RMSE)2 安装依赖项(1)Numpy...
  • 为验证方法的有效性,本研究使用高频(3s)的滴滴车辆轨迹数据进行实地验证,结果表明本方法可以有效提高稀疏车辆轨迹条件下排队长度的估计精度,所有周期平均绝对误差为3.41辆,平均绝对误差百分比为16.89%,而缺失...
  • 提出一种结合群体交互信息和个体运动信息的生成对抗网络GI-GAN。...实验表明,与S-GAN模型相比,GI-GAN模型的平均位移误差绝对位移误差分别降低了8.8%和9.2%,并且预测轨迹具有更高的精度和合理多样性。
  • 在此基础上,利用满足标定规则的粒子滤波器,校正机器人搬运轨迹的协同误差,并以此为条件推导出定位条件熵,完成基于粒子滤波机器人搬运轨迹协同定位方法的顺利应用。模拟对比实验结果显示,应用新型轨迹协同定位...
  • 核心功能是能够绘制相机的轨迹,或评估估计轨迹与真值的误差。支持多种数据集的轨迹格式(TUM、KITTI、EuRoC MAV、ROS的bag),同时支持这些数据格式之间进行相互转换。参考:视觉里程计的轨迹评估工具:evo 一 evo...
  • 然而,GPS设备有时存在定位误差较大的问题[1],导致轨迹中存在一些漂移点、回跳点、缺点等。这些点将会影响我们对路网拓扑结构的研究。因此,本文利用卡尔曼滤波对轨迹进行清洗。  简单来说,卡尔曼滤...
  • TUM数据集groundtruth轨迹与估计轨迹(ORBSLAM2运行的结果...阅读ORBSLAM的相关论文并且在UBuntu系统上编译好ORB-SLAM2后,准备运行下程序,获得估计的轨迹后,评估下轨迹误差。这里运行的是rgbd_dataset_freibur...
  • 深度LSTM神经网络的平均绝对误差、平均绝对百分误差、均方根误差均低于支持向量回归与梯度提升回归树算法。实际生产中采煤机需进行多次循环截割,考虑到实时性问题,神经网络模型需要对截割轨迹进行多步预测。为了...
  • 五个线程:tracking, semantic segmentation, local mapping, loop closing, and dense semantic map creation方法:融合语义...误差:绝对轨迹误差较ORB-SLAM2提高一个数量级 开源:https://github.com/ivipsourceco
  • evo 评测工具的使用

    2021-01-26 09:57:52
    绝对轨迹误差(ATE:abosulte trajectory error):直接计算相机位姿的真实值与SLAM系统的估计值之间的差,程序首先根据位姿的时间戳将真实值和估计值进行对齐, 然后计算每对位姿之间的差值, 并最终
  • 核心功能是能够绘制相机的轨迹,或评估估计轨迹与真值的误差。支持多种数据集的轨迹格式(TUM、KITTI、EuRoC MAV、ROS的bag),同时支持这些数据格式之间进行相互转换。在此仅对其基本功能做简要介绍。 evo工具...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,892
精华内容 1,156
关键字:

绝对轨迹误差