高精地图应用（八）标牌重建

于 2021-02-05 13:33:52 发布
阅读量374 收藏 3
点赞数 2
分类专栏： 自动驾驶实战 计算机图形学 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingcaichongchong/article/details/113661315
版权

跟踪预测后，已经能建立多帧之间标牌的一致性关系，而每一帧的外参通过前面的定位环节已经确定了，因此只要建立同名点关系，就可以用三角量测把坐标算出来了。

有一种办法是采用特征匹配的方法，通过特征点匹配建立同名点关系，而标牌还多一个单应约束，建立最小二乘问题，问题即可解。

但本文并不采用这种方法，特征匹配强依赖于特征点的个数，对照片模糊或特征比较少的要素就无能为力了，本文介绍一种更加通用的方法，直接使用目标检测框来做：

基于这样的判断：标牌角点投影到各帧图像中与目标检测的角点重投影误差时的位置就是标牌的位置，基于此建立非线性优化算法，问题得解。

算法步骤如下：

1.每一帧两两计算相机中心与标牌中心构成的射线的夹角，选出其中最大夹角，这一步是因为三角量算的精度跟基线长度是呈正比关系，因此最大夹角就能保证基线最长.

Z=\frac{b*f}{X_R-X_T}

2、将第一步选出的两帧，将标牌中心当成同名点三角化得到三维坐标：

如何三角化同名点，我们知道三维点（X,Y,Z）投影到图像平面上是通过：

d*\begin{bmatrix}u \\ v \\ 1 \end{bmatrix}=K*(R|T)*\begin{bmatrix} X \\Y \\Z \\1 \end{bmatrix}

其中，K*(R|T)是一个3*4的矩阵，设为P，则有：

d*u=P*X

两边同时叉乘u

u_\times (P*x)=0

展开后有：

\begin{bmatrix}0 &-1 &v \\ 1& 0 & -u\\ -v& u &0 \end{bmatrix}*\begin{bmatrix} P1 \\ P2 \\ P3\end{bmatrix}*X=0

继续代入得：

\left\{\begin{matrix}(vP3-P2)X=0 \\ (P1-uP3)X=0 \\ (uP2-vP1)X=0 \end{matrix}\right.

上式三个方程只能提供两个约束，因为(1)*(-u)-(2)*v=(3)

每一帧都可以提供两个约束，X总共有三个未知数，二帧就可以求解最小二乘算法了，代码如下：

bool SignVec::triangulateView(const SignVecMeta& to_vec1, const SignVecMeta& to_vec2, const Camera& camera, Eigen::Vector3d& vec3d)
{
    Eigen::Matrix3d cRb = camera.mount.rotation.matrix();
    Eigen::Vector3d cTb = camera.mount.translation;

    Eigen::Matrix3d bRw1 = to_vec1.pose.orientation.toRotationMatrix();
    Eigen::Vector3d bTw1 = to_vec1.pose.position;
    Eigen::Matrix3d R1 = bRw1 * cRb;
    Eigen::Vector3d C1 = bTw1 + bRw1 * cTb;
    Eigen::Matrix<double, 3, 4> P1 = Eigen::Matrix<double, 3, 4>::Zero();
    P1.block(0, 0, 3, 3) = R1.transpose();
    P1.col(3) = - R1.transpose() * C1; 
    P1 = camera.K * P1;

    Eigen::Matrix3d bRw2 = to_vec2.pose.orientation.toRotationMatrix();
    Eigen::Vector3d bTw2 = to_vec2.pose.position;
    Eigen::Matrix3d R2 = bRw2 * cRb;
    Eigen::Vector3d C2 = bTw2 + bRw2 * cTb;
    Eigen::Matrix<double, 3, 4> P2 = Eigen::Matrix<double, 3, 4>::Zero();
    P2.block(0, 0, 3, 3) = R2.transpose();
    P2.col(3) = - R2.transpose() * C2; 
    P2 = camera.K * P2;

    const Eigen::Matrix<double, 1, 4>& P11 = P1.block(0, 0, 1, 4);
	const Eigen::Matrix<double, 1, 4>& P12 = P1.block(1, 0, 1, 4);
	const Eigen::Matrix<double, 1, 4>& P13 = P1.block(2, 0, 1, 4);
	
	const Eigen::Matrix<double, 1, 4>& P21 = P2.block(0, 0, 1, 4);
	const Eigen::Matrix<double, 1, 4>& P22 = P2.block(1, 0, 1, 4);
	const Eigen::Matrix<double, 1, 4>& P23 = P2.block(2, 0, 1, 4);

    Eigen::Vector2d cent2d1 = to_vec1.dlSign.bBox.GetCenter();
    Eigen::Vector2d cent2d2 = to_vec2.dlSign.bBox.GetCenter();

    const double &u1 = cent2d1.x();
    const double &v1 = cent2d1.y();
    const double &u2 = cent2d2.x();
    const double &v2 = cent2d2.y();

    Eigen::Matrix4d H;
    H.block(0, 0, 1, 4) = v1 * P13 - P12;
    H.block(1, 0, 1, 4) = P11 - u1 * P13;
    H.block(2, 0, 1, 4) = v2 * P23 - P22;
    H.block(3, 0, 1, 4) = P21 - u2 * P23;

    // SVD
    Eigen::JacobiSVD<Eigen::MatrixXd> svd(H, Eigen::ComputeFullU | Eigen::ComputeFullV);
    Eigen::Matrix4d V = svd.matrixV();

    Eigen::Vector4d X = V.block(0, 3, 4, 1);
    X = X / X(3, 0);
    vec3d = X.block(0, 0, 3, 1);
    return true;
}

3.将第2步得到的三维坐标反投到第一帧上，作为深度初始值，这将代入第4步进行非线性优化：

double SignVec::calculateDepth(const Pose& pose, const Camera& camera, Eigen::Vector3d& vec3d) const
{
    Eigen::Matrix3d cRb = camera.mount.rotation.matrix();
    Eigen::Vector3d cTb = camera.mount.translation;

    Eigen::Matrix3d bRw0 = pose.orientation.toRotationMatrix();
    Eigen::Vector3d bTw0 = pose.position;
    Eigen::Matrix3d R0 = bRw0 * cRb;
    Eigen::Vector3d C0 = bTw0 + bRw0 * cTb;

    Eigen::Vector3d camera3D = R0.transpose() * (vec3d - C0);
    return camera3D.z();
}

4.将第二步得到深度将第一帧的标牌角点投影到三维坐标系中。将逆深度作为优化量，将标牌角点到每一帧图像的反投影误差作为残差，建立非线性优化问题。（为了使其更符合正态分布，这里采用的是逆深度，即深度的导数）

\begin{bmatrix}u_i \\ v_i \end{bmatrix}=K*(R|T)* (C_0+\lambda*K^{-1}*\begin{bmatrix} u_0\\v_0 \\1 \end{bmatrix})

构建残差：

\begin{bmatrix}r_u\\r_v\end{bmatrix}=\begin{bmatrix}u_i\\v_i\end{bmatrix}-\begin{bmatrix}u_{corner}\\v_{corner} \end{bmatrix}

因此：

\begin{bmatrix} \frac{\partial r_u}{\lambda}\\ \frac{\partial r_v}{\lambda}\end{bmatrix}=\begin{bmatrix}\ f_x * \frac{1}{Z'} & 0 & -f_x* \frac{X'}{Z'^2} \\ 0 & f_y * \frac{1}{Z'} & -f_y * \frac{Y'}{Z'^2} \end{bmatrix}*R*(\frac{-1}{\lambda^2})*K^{-1}*\begin{bmatrix}u_0\\v_0\end{bmatrix}

代码如下：

void SignVec::refineDepth(const std::vector<SignVecMeta> &to_vecs, const Camera &camera, double &depth) const
{
    Eigen::Matrix3d cRb = camera.mount.rotation.matrix();
    Eigen::Vector3d cTb = camera.mount.translation;

    int N = to_vecs.size();
    std::vector<Eigen::Vector2d> q1(4), q2(4);
    q1[0] = Eigen::Vector2d(to_vecs[0].dlSign.bBox.GetMinx(),  to_vecs[0].dlSign.bBox.GetMiny());
    q1[1] = Eigen::Vector2d(to_vecs[0].dlSign.bBox.GetMinx() + to_vecs[0].dlSign.bBox.Width(), to_vecs[0].dlSign.bBox.GetMiny());
    q1[2] = Eigen::Vector2d(to_vecs[0].dlSign.bBox.GetMinx() + to_vecs[0].dlSign.bBox.Width(), to_vecs[0].dlSign.bBox.GetMiny() + to_vecs[0].dlSign.bBox.Height());
    q1[3] = Eigen::Vector2d(to_vecs[0].dlSign.bBox.GetMinx(),  to_vecs[0].dlSign.bBox.GetMiny() + to_vecs[0].dlSign.bBox.Height());

    Eigen::Matrix3d bRw0 = to_vecs[0].pose.orientation.toRotationMatrix();
    Eigen::Vector3d bTw0 = to_vecs[0].pose.position;
    Eigen::Matrix3d R0 = bRw0 * cRb;
    Eigen::Vector3d C0 = bTw0 + bRw0 * cTb;

    double inverse_depth  = 1.0 / depth;
    std::vector<Eigen::Vector3d> Points3d(4), Ray(4);
    for (int i = 0; i < 4; i++)
    {
        //let ray length aligned with body is as same as depth
        Ray[i] = cRb * camera.K.inverse() * Eigen::Vector3d(q1[i].x(), q1[i].y(), 1.0);
        Ray[i] = Ray[i] / Ray[i].x();
        Ray[i] = bRw0 * Ray[i];
        Ray[i].normalize();
        Points3d[i] = C0 + depth *  Ray[i];
    }

    double stopThresholdLM = 0.0;
    double currentEro = 0.0;
    double currentLambda = 0.0;
    double ni = 2.0;

    //Generate init lamda
	{
        Eigen::MatrixXd H = Eigen::MatrixXd::Zero(1, 1);
        for(int i = 1; i < N; i++)
        {
            q2[0] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx(),  to_vecs[i].dlSign.bBox.GetMiny());
            q2[1] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx() + to_vecs[i].dlSign.bBox.Width(), to_vecs[i].dlSign.bBox.GetMiny());
            q2[2] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx() + to_vecs[i].dlSign.bBox.Width(), to_vecs[i].dlSign.bBox.GetMiny() + to_vecs[i].dlSign.bBox.Height());
            q2[3] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx(),  to_vecs[i].dlSign.bBox.GetMiny() + to_vecs[i].dlSign.bBox.Height());

            Eigen::Matrix3d bRw = to_vecs[i].pose.orientation.toRotationMatrix();
            Eigen::Vector3d bTw = to_vecs[i].pose.position;
            Eigen::Matrix3d R = bRw * cRb;
            Eigen::Vector3d C = bTw + bRw * cTb;

            for (int j = 0; j < 4; j++)
            {
                Eigen::Vector3d camera3D = R.transpose() * (Points3d[j] - C);
                if (camera3D[2] <= 0.0)
                    continue;

                Eigen::Vector3d uvw = camera.K * camera3D;
                Eigen::Vector2d uv(uvw[0] / uvw[2], uvw[1] / uvw[2]);
                Eigen::Vector2d residual = uv - q2[j];
                currentEro += residual.transpose() * residual;

                Eigen::Matrix<double, 2, 3> J_F;
                J_F << camera.fx() / camera3D.z(), 0.0, -camera.fx() * camera3D.x() / (camera3D.z() * camera3D.z()),
                    0.0, camera.fy() / camera3D.z(), -camera.fy() * camera3D.y() / (camera3D.z() * camera3D.z());
                Eigen::Matrix<double, 2, 1> J_aux = J_F * R.transpose() * (- 1.0 / (inverse_depth * inverse_depth)) * Ray[j];
			    H += J_aux.transpose() * J_aux;
            }
		}

        stopThresholdLM = 1e-6 * currentEro;
        double maxDiagonal = std::max(std::fabs(H(0, 0)), maxDiagonal);
        double tau = 1e-5;
        currentLambda = tau * maxDiagonal;
    }

    auto robustWeightCauchy = [=](double norm_res) -> double {
		return std::sqrt(1.0 / (1.0 + norm_res * norm_res));
	};

	int iter = 0;
	bool stop = false;
	while (!stop && iter < 30)
	{
		bool oneStepSuccess = false;
        int false_cnt = 0;

		while (!oneStepSuccess)
		{
            Eigen::MatrixXd H = Eigen::MatrixXd::Zero(1, 1);
            Eigen::MatrixXd g = Eigen::MatrixXd::Zero(1, 1);

            for (int i = 1; i < N; i++)
            {
                Points3d[0] = C0 + 1.0 / inverse_depth * Ray[0];
                Points3d[1] = C0 + 1.0 / inverse_depth * Ray[1];
                Points3d[2] = C0 + 1.0 / inverse_depth * Ray[2];
                Points3d[3] = C0 + 1.0 / inverse_depth * Ray[3];

                q2[0] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx(),  to_vecs[i].dlSign.bBox.GetMiny());
                q2[1] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx() + to_vecs[i].dlSign.bBox.Width(), to_vecs[i].dlSign.bBox.GetMiny());
                q2[2] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx() + to_vecs[i].dlSign.bBox.Width(), to_vecs[i].dlSign.bBox.GetMiny() + to_vecs[i].dlSign.bBox.Height());
                q2[3] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx(),  to_vecs[i].dlSign.bBox.GetMiny() + to_vecs[i].dlSign.bBox.Height());

                Eigen::Matrix3d bRw = to_vecs[i].pose.orientation.toRotationMatrix();
                Eigen::Vector3d bTw = to_vecs[i].pose.position;
                Eigen::Matrix3d R = bRw * cRb;
                Eigen::Vector3d C = bTw + bRw * cTb;

                for (int j = 0; j < 4; j++)
                {
                    Eigen::Vector3d camera3D = R.transpose() * (Points3d[j] - C);
                    if (camera3D[2] <= 0.0)
                        continue;

                    Eigen::Vector3d uvw = camera.K * camera3D;
                    Eigen::Vector2d uv(uvw[0] / uvw[2], uvw[1] / uvw[2]);
                    Eigen::Vector2d residual = uv - q2[j];
                    
                    double err_i_norm = residual.norm();
				    double weight = robustWeightCauchy(err_i_norm);

                    Eigen::Matrix<double, 2, 3> J_F;
                    J_F << camera.fx() / camera3D.z(), 0.0, -camera.fx() * camera3D.x() / (camera3D.z() * camera3D.z()),
                        0.0, camera.fy() / camera3D.z(), -camera.fy() * camera3D.y() / (camera3D.z() * camera3D.z());
                    Eigen::Matrix<double, 2, 1> J_aux = J_F * R.transpose() * (- 1.0 / (inverse_depth * inverse_depth)) *  Ray[j];
                    
                    H += J_aux.transpose() * J_aux * weight;
                    g -= J_aux.transpose() * residual * weight;
                }
            }

            H(0, 0) += currentLambda;

			Eigen::Matrix<double, 1, 1> delta = H.colPivHouseholderQr().solve(g);
            if (delta.squaredNorm() < EPS || false_cnt > 10)
            {
                stop = true;
                break;
            }

			inverse_depth += delta[0];

			double scale = 0;
            scale = delta.transpose() * (currentLambda * delta + g);
            scale += 1e-3;

			double temp_err = 0.0;
            for (int i = 1; i < N; i++)
            {
                Points3d[0] = C0 + 1.0 / inverse_depth * Ray[0];
                Points3d[1] = C0 + 1.0 / inverse_depth * Ray[1];
                Points3d[2] = C0 + 1.0 / inverse_depth * Ray[2];
                Points3d[3] = C0 + 1.0 / inverse_depth * Ray[3];

                q2[0] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx(),  to_vecs[i].dlSign.bBox.GetMiny());
                q2[1] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx() + to_vecs[i].dlSign.bBox.Width(), to_vecs[i].dlSign.bBox.GetMiny());
                q2[2] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx() + to_vecs[i].dlSign.bBox.Width(), to_vecs[i].dlSign.bBox.GetMiny() + to_vecs[i].dlSign.bBox.Height());
                q2[3] = Eigen::Vector2d(to_vecs[i].dlSign.bBox.GetMinx(),  to_vecs[i].dlSign.bBox.GetMiny() + to_vecs[i].dlSign.bBox.Height());

                Eigen::Matrix3d bRw = to_vecs[i].pose.orientation.toRotationMatrix();
                Eigen::Vector3d bTw = to_vecs[i].pose.position;
                Eigen::Matrix3d R = bRw * cRb;
                Eigen::Vector3d C = bTw + bRw * cTb;

                for (int j = 0; j < 4; j++)
                {
                    Eigen::Vector3d camera3D = R.transpose() * (Points3d[j] - C);
                    if (camera3D[2] <= 0.0)
                        continue;

                    Eigen::Vector3d uvw = camera.K * camera3D;
                    Eigen::Vector2d uv(uvw[0] / uvw[2], uvw[1] / uvw[2]);
                    Eigen::Vector2d residual = uv - q2[j];
                    temp_err += residual.transpose() * residual;
                }
            }

            double rho = (currentEro - temp_err) / scale;
            if (rho > 0 && std::isfinite(temp_err)) // last step was good
            {
                double alpha = 1.0 - pow((2 * rho - 1), 3);
                alpha = std::min(alpha, 2. / 3.);
                double scaleFactor = (std::max)(1. / 3., alpha);
                currentLambda *= scaleFactor;
                ni = 2;
                currentEro = temp_err;
                oneStepSuccess = true;
            }
            else
            {
                currentLambda *= ni;
                ni *= 2;
                oneStepSuccess = false;
            }

			if(!oneStepSuccess)
            {
				depth -= delta[0];
				false_cnt++;
            }
            else
            {
                false_cnt = 0;
            }
		}
		iter++;
		if (sqrt(currentEro) <= stopThresholdLM)
			stop = true;
	}
    depth = 1.0 / inverse_depth;
}

最后的重建结果如图：

 

 

 

 

神气爱哥
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
智能网联汽车高精地图白皮书-2020.pdf
04-17
智能网联汽车高精地图白皮书-2020.pdf
[自动驾驶] 自动驾驶高精度地图——3D 道路环境的重建
开源节流
12-09 1333
1，高精度地图是对 3D 道路环境的重建 高精度地图是实现 L3 级别以上辅助/自动驾驶的重要一环。高精度地图是指高精度、精细化定义的地图，可以描述为对3D道路环境的重建。高精度地图含有大量道路矢量元素信息（车道线位置、类型、宽度等）以及车道周边的固定对象信息（交通信号灯、交通标志、障碍物、路边地标等），形成对路网精确的三维表征（厘米级精度），比如路面的几何结构、道路标示线的位置、周边道路环境的...
高精度地图应用（三）单帧重建
青菜虫虫的专栏
08-16 778
单帧重建是指车道线的重建，为何选择车道线是因为车道线输出稳定，每一帧图像都有，而且车道线特征很强，语义分割技术比较成熟。首先，需要对原图进行语义分割以提取车道线，如： 然后，在语义分割基础上进行折线拟合，我这里就直接采用了opencv直线拟合的方式，代码： std::vector<Eigen::Vector2d> utils::Fitting2d(const std::vector<cv::Point2d>& geometry2d, cv::Mat K, c...
一文详解高精地图：自动驾驶的必由之路丨曼孚科技
manfukeji的博客
11-03 2420
依据SAE International对自动驾驶发展阶段的划分，目前自动驾驶基本处于L2与L3阶段之间，典型的应用场景包括高级巡航、自动跟车、自动转向、自动刹车、紧急刹停等。 随着未来一段时间内，自动驾驶级别的不断提升，自动驾驶系统需要面对与处理的路况信息将越来越复杂，这不仅需要“感知、决策与执行”这套核心技术体系愈发坚实与强大，同时也需要其他技术体系的有力支撑，比如高精地图。 作为自动驾驶系统的重要组成部分，高精地图可以有效提升自动驾驶汽车的行驶安全度，强化自动驾驶系统的整体感知能力和决策能力，是实现.
自动驾驶：高精地图
OceanStar的博客
02-01 1784
查看提交历史 在某个项目中运行git log，可以查看提交历史 默认按照时间先后顺序列出所有的提交，最近的更新排在最上面 列出每个提交的 SHA-1 校验和、作者的名字和电子邮件地址、提交时间以及提交说明。 如果想要不同于默认格式的方式展示提交历史， 可以使用--pretty。选项有oneline，short，full 和 fuller git log --pretty=oneline format，可以定制记录的显示格式 $ git log --pretty=format:"%h - %
智能网联汽车高精地图白皮书.pdf
05-28
中国智能网联汽车产业创新联盟、自动驾驶地图与定位工作组联合出品的权威白皮书。
百度智驾高精地图产品介绍
06-28
国内智驾如火如荼发展，百度作为高精地图提供商，其高精地图产品是有力基座。材料介绍了：百度智驾地图产品线、高精地图优势，高精地图产品介绍，高精地图的生产发布更新
自动驾驶之高精地图.pdf
最新发布
04-19
自动驾驶之高精地图的作用
sfm流程概述
热门推荐
青菜虫虫的专栏
03-16 2万+
经过一段时间的刻苦钻研,终于摸到SFM的门了,在此把流程稍微捋一下,后续学到新的慢慢丰富吧 1）第一步是特征提取,一般采用SIFT算子,因其具有尺度和旋转不变性 2）第二步是匹配和建立track,图像对两两匹配,一般采用欧式距离.有两种方法：  粗暴匹配,对所有特征点都穷举计算距离邻近搜索,建立KD树,缩小搜索范围,能提高效率,但也有可能不是最优,所以邻域取值是关键,越大越准确,越大
证明AX=0的最小二乘解是ATA最小特征值对应的特征向量
青菜虫虫的专栏
02-10 8767
坑爹的,csdn没法编辑公式,我只能在word上写好截图了。 因此,如果能构造AX=0，则最小二乘解就直接求ATA的最小特征解就可以了，这里举一个平面拟合的例子： 假如有一束点云,如何从点云里把平面求出来。啥也不说了，上代码吧： Bool ComplanationFit(Navinfo::Engine::Geometries::Coordinate *pPoints, Int
利用PCA计算点云的法线
青菜虫虫的专栏
07-07 8646
我们知道PCA可以用来降维,并使降维后的数据尽可能保持原来的特征。比如二维散乱的点： 经过PCA降维后,编程了一维直线,而该直线保证点尽可能分散,变成如下图(跟最小二乘是一样的)： 具体原理可参考http://blog.codinglabs.org/articles/pca-tutorial.html 前面说的是二维降到一维时的情况，假如我们有一堆散乱的三维点云,则可以这样计算法
Eigen最小二乘法拟合三次曲线
青菜虫虫的专栏
03-17 5747
用osg做了可视化验证,交互点都存在v3d中了，用了三次曲线作为曲线方程，即y= ax3 + bx2 + cx + d,以一组观测值x,y序列去求未知数a,b,c,d，当然观测个数必须大于4 #include #include #include #include #include "OrthoManipulator.h" #include using namespa
利用半自动化从点云中提取规则多边形
青菜虫虫的专栏
01-20 3099
高精度地图一个重要的矢量数据就是交通标志,比如地面的字符、箭头，路边的限速牌等。在我理解看来，交通标志与车道线是同等重要的，因为它是无人车初始定位的重要匹配依据。写到这就扯远了，我今天要讨论的是，如何用交互的方式从点云中提取规则多边形，这篇文章以地面字符箭头为例，也就是矩形的提取。首先，算法输入是已经分类好的初始点云，如下图所示： 这里所说的半自动化是需要用户在点云上点一下，以生成一个种子点，作
ros跑通orbslam2遇到的问题
青菜虫虫的专栏
01-15 2073
主要参照两个博客:ROS Kinetic安装 ORBSLAM2安装 在安装中遇到些问题1、安装kinetic失败sudo apt-get install ros-kinetic-desktop-full执行此命令，很快就结束了，我还以为我的网速快呢，原来是公司把端口给限制了，opt下面根本什么都没有，搬回家里运行了2个小时终于装完了。2、编译ORB_Slame2会遇到error: ‘uslee
高精地图应用（四）横向定位
青菜虫虫的专栏
09-10 1606
这里的横向定位是基于ICP算法的改进实现的3d-3d的配准方法，步骤：1.将单帧重建车道线的形值点，向高精度地图中的车道线做垂足，考虑到不受高程差异的影响，这里是在平面上完成的。求得的形值点与垂足就组成了一对同名点，我将形值点命名为source，垂足命名为target。会生成很多这样的同名点。2. ...
高精度地图（五）纵向定位
青菜虫虫的专栏
02-03 1097
当横向定位成功后，无人车视野已经被限制住了，这时标牌等视觉要素跟高精地图的标牌只差了一个纵向上的偏差，对于我们人类来说是很容易找到对应关系的。 机器找到对应关系也很简单，这个就要用到著名的匈牙利算法，这里就不过多介绍了，请参考别的文章，我们只说过程： 1.将高精度地图通过 投影到图像上，如上图，这是5个矩形。目标检测同样有5个矩形（红色阴影），于是可以构建二部图 接下来就是确定每个标牌投影的矩形与目标检测每个矩形之间的权值，以确定最佳匹配关系，这里就简单使用中心点的位置以及长宽比...
高精度地图应用（一）自动驾驶初探
青菜虫虫的专栏
07-26 674
以下都是我的个人理解，说的不对的欢迎狂怼。 借用apollo的架构说事： 自动驾驶由这7部分组成： 1.感知。就是指传感器的输入，包括激光雷达、视觉图像、GPS、惯导、毫米波雷达等都可以归类为感知。 2.地图。就是指高精度地图，它与普通导航地图的最大区别是：高精度地图主要用于定位，是给机器看的。导航地图主要用于路径规划，是给人看的。高精度地图有着20cm绝对精度，5cm相对精度，具有全要素，车道集级等等，在我看来其就是对真实世界的标注而已，跟图像标注没有什么本质区别...
Apollo高精地图
03-24
Apollo高精地图是一款由百度公司开发的高精度地图产品。它是为自动驾驶和智能...5. 开放接口：Apollo高精地图提供了丰富的开放接口，方便开发者进行地图数据的查询、更新和应用开发，支持自定义的地图标注和功能扩展。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神气爱哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值