Derrr...

VINS_MONO系列：(四)紧耦合VIO实现

1、写在前面

2、算法推导

2.1、IMU因子

2.2、视觉因子

2.3、边缘化因子

3、代码实现

4、反思与探讨

5、参考文献

1、写在前面

这篇文章主要介绍VINS的整个VIO的实现方法，包括理论的公式推导部分和代码部分，也就是对应的esimator部分的代码内容。理论部分主要介绍三种因子（IMU预积分因子、视觉因子和边缘化因子）的残差构造及雅克比推导，代码部分主要展示如何通过ceres构造这三种因子。

2、算法推导

VINS的VIO是基于紧耦合框架实现的，其本质就是一个基于滑动窗口的和图优化的VIO，整个紧耦合VIO的示意图如图1所示。

图1

整个包含的状态量有

其中 $\small \chi$ 为状态向量， $\small x_k$ 为第K帧的IMU状态量， $\small x^b_c$ 为相机与IMU间的外参， $\small \lambda$ 为特征的逆深度值。

整个VIO的优化问题可以表示为

$\small \min_{\chi }\left \{ \left \| r_p-H_p\chi \right \|^2 + \sum_{k\in B}^{}\left \|r_B(\hat{z}^{b_k}_{b_{k+1}},\chi ) \right \|^2_{P^{b_k}_{b_{k+1}}}+\sum_{(l,j)\in C}^{} \rho (\left \| r_C(\hat{z}^{C_j}_l,\chi) \right \|^2_{P^{C_j}_{l}})\right \}$

式中第一项代表边缘化残差，第二项对应IMU残差，第三项对应视觉重投影残差，其中 $\small \left \| . \right \|$ 表示马氏距离， $\small {P^{b_k}_{b_{k+1}}},{P^{C_j}_{l}}$ 分别为IMU因子和视觉因子的信息矩阵，下面分别介绍各个因子的残差构成及对应雅克比的推导，最后再对外参标定和同步时间标定进行介绍。

2.1、IMU因子

VINS中的IMU因子与传统[2]IMU预积分的形式不同，其具体的残差和雅克比推导可以参考我的另一篇文章，这里就不再进行赘述。

VINS_MONO系列：(二)IMU预积分详细推导_Derrr...的博客-CSDN博客

2.2、视觉因子

视觉因子中的残差即为重投影误差，其本质为不同位姿对于同一个landmark的观察应该是一致的，即将空间中的landmark投影到各个能观察到该landmark的关键帧中，其投影的像素坐标及真实的观测值应该是重合的。但由于各种误差的存在，这个投影坐标及观察值往往不完全重合，而这中间的差值即为对应的重投影误差。视觉因子中优化的状态量为

$\small \chi =[p^w_{b_i},p^w_{b_j}],[q^w_{b_i},q^w_{b_j}],[p^b_{c},q^b_{c}],[\lambda ]$

原文视觉残差的推导会将残差投影到一个正切平面上再进行计算，但是在实际代码实现上还是使用了原本的重投影误差，为了和代码保持一致，这里对原本的重投影误差进行推导

对于空间中的一个特征点P，其第j帧的归一化平面坐标为 $\small P^{C_j}_l$ ，第j帧的观测值为 $\small \hat{P}^{C_j}_l$ ，则其对应的残差可以表示为

$\small r_c=P^{C_j}_l-\hat{P}^{C_j}_l$

其中

$\small P^{C_j}_l=R^c_b\left \{R^{b_j}_w[R^w_{b_i}(R^b_c\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}$

其中 $\small \hat{P}^{C_i}_l$ 为第i帧第l个特征归一化平面的观测值。

各项雅克比为

$\small \frac{\partial r_c}{\partial p^w_{b_i}}=R^c_bR^{b_j}_w$

$\small \frac{\partial r_c}{\partial p^w_{b_j}}=-R^c_bR^{b_j}_w$

$\small \frac{\partial r_c}{\partial q^w_{b_i}}=\lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{R^{b_j}_w[R^w_{b_i}Exp(\delta \theta )(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}-R^c_b\left \{R^{b_j}_w[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}}{\delta \theta}$

$\small \approx \lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{R^{b_j}_w[R^w_{b_i}(I+\delta \theta )(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}-R^c_b\left \{R^{b_j}_w[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}}{\delta \theta}$

$\small =\lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{R^{b_j}_w[R^w_{b_i}(\delta \theta )^{\wedge }(\cdot )] \right \}}{\delta \theta}=-R^c_bR^{b_j}_wR^w_{b_i}(\cdot )^{\wedge }$

$\small \frac{\partial r_c}{\partial q^w_{b_j}}=\lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{[R^w_{b_j}Exp(\delta \theta )]^{-1}[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}-R^c_b\left \{R^{b_j}_w[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}}{\delta \theta}$

$\small \approx \lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{[R^w_{b_j}(I+\delta \theta )]^{-1}[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}-R^c_b\left \{R^{b_j}_w[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}}{\delta \theta}$

$\small = \lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{-\delta \theta ^{\wedge }[R^w_{b_j}]^{-1}[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}] \right \}}{\delta \theta}=\lim_{\delta \theta \rightarrow 0}\frac{R^c_b\left \{[R^w_{b_j}]^{-1}[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}]\right \}^{\wedge }\delta \theta }{\delta \theta}$

$\small =R^c_b\left \{[R^w_{b_j}]^{-1}[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}]\right \}^{\wedge }$

$\small \frac{\partial r_c}{\partial p^b_{c}}=R^c_b(R^{b_j}_wR^w_{b_i}-I)$

$\small \frac{\partial r_c}{\partial q^b_{c}}=\lim_{\delta \theta \rightarrow 0}\frac{[R^b_cExp(\delta \theta )]^{-1}\left \{R^{b_j}_w[R^w_{b_i}(R^b_cExp(\delta \theta )\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}-\left \{\cdot \right \}}{\delta \theta}$

$\small \approx \lim_{\delta \theta \rightarrow 0}\frac{(I-\delta \theta ^\wedge )R^c_b\left \{R^{b_j}_w[R^w_{b_i}(R^b_c(I+\delta \theta ^\wedge )\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}-\left \{\cdot \right \}}{\delta \theta}$

$\small \approx \lim_{\delta \theta \rightarrow 0}\frac{-\delta \theta ^\wedge R^c_b\left \{R^{b_j}_w[R^w_{b_i}(R^b_c(I+\delta \theta ^\wedge )\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}+R^c_b\left \{R^{b_j}_w[R^w_{b_i}(R^b_c\delta \theta ^\wedge \frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}}{\delta \theta}$

$\small =\left \{ R^c_b\left \{R^{b_j}_w[R^w_{b_i}(R^b_c\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}\right \}^\wedge +R^c_b{R^{b_j}_wR^w_{b_i}R^b_c (\frac{\hat{P}^{C_i}_l}{\lambda})^\wedge$

$=(R^c_bR^{b_j}_wR^w_{b_i}R^b_c\frac{\hat{P}^{C_i}_l}{\lambda })^\wedge + \left \{ R^c_b[R^{b_j}_w(R^w_{b_i}p^b_c+p^w_{b_i}-p^w_{b_j}) -p^b_c]\right \}^\wedge+R^c_b{R^{b_j}_wR^w_{b_i}R^b_c (\frac{\hat{P}^{C_i}_l}{\lambda})^\wedge$

$\small \frac{\partial r_c}{\partial\lambda }=-R^c_bR^{b_j}_wR^w_{b_i}R^b_c\frac{\hat{P}^{C_i}_l}{\lambda ^2}$

其中

$\small (\cdot )=(R^b_c\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)$

$\small \left \{ \cdot \right \}=R^c_b\left \{R^{b_j}_w[R^w_{b_i}(R^b_c\frac{1}{\lambda }\hat{P}^{C_i}_l+p^b_c)+p^w_{b_i}-p^w_{b_j}] -p^b_c\right \}$

至此视觉因子中的残差，以及残差关于状态量的雅克比矩阵推导完毕。最后为了与代码中的雅可比矩阵保持一致，各残差相对于状态量的雅可比可以整理为：

$jacobian[0]=[\frac{\partial r_c}{\partial p^w_{b_i}},\frac{\partial r_c}{\partial q^w_{b_i}}]_{3\times 7}=[R^c_bR^{b_j}_w,-R^c_bR^{b_j}_wR^w_{b_i}(\cdot )^{\wedge }]$

$jacobian[1]=[\frac{\partial r_c}{\partial p^w_{b_j}},\frac{\partial r_c}{\partial q^w_{b_j}}]_{3\times 7}=[-R^c_bR^{b_j}_w,R^c_b\left \{[R^w_{b_j}]^{-1}[R^w_{b_i}(\cdot )+p^w_{b_i}-p^w_{b_j}]\right \}^{\wedge }]$

$jacobian[2]=[\frac{\partial r_c}{\partial p^b_{c}},\frac{\partial r_c}{\partial q^b_{c}}]_{3\times 7}=[R^c_b(R^{b_j}_wR^w_{b_i}-I),(R^c_bR^{b_j}_wR^w_{b_i}R^b_c\frac{\hat{P}^{C_i}_l}{\lambda })^\wedge + \left \{ R^c_b[R^{b_j}_w(R^w_{b_i}p^b_c+p^w_{b_i}-p^w_{b_j}) -p^b_c]\right \}^\wedge+R^c_b{R^{b_j}_wR^w_{b_i}R^b_c (\frac{\hat{P}^{C_i}_l}{\lambda})^\wedge]$

$jacobian[3]=[\frac{\partial r_c}{\partial\lambda }]_{3\times 1}=[-R^c_bR^{b_j}_wR^w_{b_i}R^b_c\frac{\hat{P}^{C_i}_l}{\lambda ^2}]$

2.3、边缘化因子

这里首先说说什么是边缘化，边缘化就是在进行图优化的时候，为了保持实时性，对优化变量的维度控制在一定的程度的操作，在VINS中对应的就是滑动窗口的处理。既然是滑动窗口，就涉及到了对老旧图像帧的处理问题，最最直观的想法是每来一帧新的图像，就直接丢弃原来滑窗中最老的帧，然后对滑窗内的帧进行优化。这种朴素的做法显然会导致这样一个问题：没有了第一帧的约束，那我们只能约束滑窗内每帧之间的相对位姿，而不能约束它们的绝对位姿（相对[0,0,0]的位姿）因此，进行边缘化时我们需要将丢弃的图像帧也作为一个约束项，加入到我们的优化问题中，这也是VINS里面对边缘化的处理方法，将边缘化掉的帧作为先验约束加入到损失函数中进行计算。

在理解边缘化的时候，我们需要把握边缘化的核心是什么？边缘化的作用是什么？我的理解是边缘化一方面控制优化维度，保持计算的实时性；另一方面，它相当于对现在还在滑窗中的优化变量进行约束，不至于让滑窗中优化前后的数值相差太远。可以理解为，被边缘化的变量已经固定了，然后我们基于这些已经固定的量去优化滑窗里的内容。所以在实际实现的时候，首先我们需要找到需要边缘化的帧，然后找出该帧包含哪些因子，然后找到这些和这些因子相关联的优化变量，然后再对这些优化变量构建残差项，这大体就是VINS在边缘化上实现的总体逻辑。

VINS当中边缘化有两种形式，分别是MARGIN_OLD和MARGIN_SECOND_NEW，对应触发逻辑是：当前后帧追踪的特征较少或前后帧视差较大时进行MARGIN_OLD的操作，否则进行MARGIN_SECOND_NEW。两个不同的操作对应边缘化的过程也不同，具体为：

MARGIN_OLD是边缘化滑窗中最老的一帧，找到最老帧相关的因子进行边缘化处理。
MARGIN_SECOND_NEW则是丢弃当前帧的前一帧，并将预积分的结果叠加到当前帧上。

这里以MARGIN_OLD为例介绍整个边缘化的过程

记录last_marginalization_info中当前滑窗中第一帧的位姿和速度；
记录当前滑窗中第一帧的位姿和速度；
记录当前滑窗中第一帧看到的特征；
对之前找到的位姿、速度、特征等进行多线程边缘化，具体方法是舒尔补，求解出新的矩阵和矩阵，这里记为 $H^*_{0}$ 和 $b^*_{0}$ ;
对 $H^*_{0}$ 和 $b^*_{0}$ 进行分解，求出等价的雅克比和残差：

$H^*_0=J^T_L\cdot J_L$

$b^*_0=J^T_L\cdot e_p$

的求解比较方便，可以直接对 $H^*_{0}$ 进行SVD分解获得，而对于残差，由于状态量发生变化时也会发生变化，因此需要推导的一般形式：

$b^*=b^*_0+\frac{\partial b}{\partial x}dx=b^*_0+J^T_L\frac{\partial e_p}{\partial x}=b^*_0+J^T_LJ_Ldx=b^*_0+H_0dx$

因此

$e_p=(J^T_L)^{-1}\cdot (b^*_0+H_0dx)=(J^T_L)^{-1}\cdot b^*_0+J_Ldx$

其中为当前状态量与计算雅克比时的线性化点的差。计算出等价雅克比和新的残差后，就可以交给ceres求解器进行计算，求出新的状态增量了。

需要补充的是，第五步求解等价雅克比和残差不是同步进行的，因为残差的变化需要在下一帧图像到来并进行优化后才会发生变化，因此代码里的做法是计算当前帧的等价雅克比和记录 $e_0=(J^T_L)^{-1}\cdot b^*_0$ ，下一次优化时再计算新的残差。

边缘化是SLAM中比较重要且较难理解的部分，虽然核心相同，都是为了将求解联合分布替换为求解条件概率分布，但是不同的开源算法都有不同的实现方式，而且其中还涉及到FEJ问题，由于篇幅有限，这里就不再深入具体的展开，后续会考虑再针对SLAM中的边缘化问题再开一篇文章深入讨论，感兴趣的同学可以参考论文[2]和[3][4]中关于边缘化的解析。

2.4、同步时间标定

虽然这一部分的内容没有直接出现在VINS的文章中，但也是VINS实现中非常重要的部分，以至于在VINS_Fusion中作为默认的状态量进行优化。这一部分的工作是秦通在[3]中的主要内容，这篇论文也是IROS2018的Best Student Paper，可见其重要程度。

在具体推导相关的雅可比矩阵前，先介绍一下同步时间的概念。通常的VIO系统主要包含相机和IMU两种传感器，一般我们都会运用各自的时间戳来对image data和IMU data做时间对齐，然后再进行后续的计算。但是事实上，相机在实际曝光、获取数据的时刻和数据打上时间戳的时刻是不一致的，其中可能相差着几毫秒到几十毫秒不等，而此时运用相机数据的时间戳去和IMU进行时间对齐就会引入误差，我们可以通过图2来辅助理解。图的上半部分是相机真实的采样时间，而下半部分则是相机数据的打标时间，可以看到其中相差了一个时间，又由于IMU数据往往能达到100HZ以上的频率，因此一个时间内会相差几个乃至几十个IMU数据，若此时系统的运动非常剧烈，则很容易恶化Tracking的结果。

图2

需要计算出，就要把它引入到残差方程中，然后再推导其对应的雅可比矩阵即可。作者首先假设在td时间内相机速度是一定的，即

$V^k_l=(\begin{bmatrix} u^{k+1}_l\\v^{k+1}_l \end{bmatrix}-\begin{bmatrix} u^{k}_l\\v^{k}_l \end{bmatrix})/(t_{k+1}-t_k)$

其中代表第k时刻第l个特征点的速度。如果数据实际采集时间和打标时间存在一个时间误差，且在时间内匀速运动，我们可以理解为实际的特征点的位置需要在原来位置的基础上增加一个像素距离d：

因此重投影误差可以重写为

$e^k_l=z^k_l(t_d)-\pi({R^w_{c_k}}^T(P_l-p^w_{c_k}))$

$z^k_l=\begin{bmatrix} u^k_l\\v^k_l \end{bmatrix}+V^k_l\cdot t_d$

其中为k时刻第l个特征的重投影误差， $[R^w_{c_k},p^w_{c_k}]$ 为第k时刻的相机位姿。对于采用逆深度来参数化特征点的重投影误差可以表示为

$e^k_l=z^k_l(t_d)-\pi({R^w_{c_k}}^T(\frac{1}{\lambda }z^{k+1}_l(t_d)-p^w_{c_k}))$

$z^k_l=\begin{bmatrix} u^k_l\\v^k_l \end{bmatrix}+V^k_l\cdot t_d$

$z^{k+1}_l=\begin{bmatrix} u^{k+1}_l\\v^{k+1}_l \end{bmatrix}+V^{k+1}_l\cdot t_d$

将上式残差方程中（并不是直接代入），并推导重投影误差相对同步时间的雅可比，有

$\frac{\partial r_c}{\partial t_d}=\frac{\partial p^{C_j}_l}{\partial \hat{p}^{C_i}_l}\cdot \frac{\partial \hat{p}^{C_i}_l}{\partial t_d}-\frac{\partial \hat{p}^{C_j}_l}{\partial t_d}=R^c_bR^{b_j}_wR^w_{b_i}R^b_c\frac{1}{\lambda }\cdot V^i_l-V^j_l$

3、代码实现

这里直接展示各个因子对应的雅可比和残差的计算部分

视觉因子

bool ProjectionTdFactor::Evaluate(double const *const *parameters, double *residuals, double **jacobians) const
{
    TicToc tic_toc;
    // 取出待优化状态量
    Eigen::Vector3d Pi(parameters[0][0], parameters[0][1], parameters[0][2]);
    Eigen::Quaterniond Qi(parameters[0][6], parameters[0][3], parameters[0][4], parameters[0][5]);

    Eigen::Vector3d Pj(parameters[1][0], parameters[1][1], parameters[1][2]);
    Eigen::Quaterniond Qj(parameters[1][6], parameters[1][3], parameters[1][4], parameters[1][5]);

    Eigen::Vector3d tic(parameters[2][0], parameters[2][1], parameters[2][2]);
    Eigen::Quaterniond qic(parameters[2][6], parameters[2][3], parameters[2][4], parameters[2][5]);

    double inv_dep_i = parameters[3][0];

    double td = parameters[4][0];

    Eigen::Vector3d pts_i_td, pts_j_td;
    // 运用t_d对特征点的像素坐标进行修正
    pts_i_td = pts_i - (td - td_i + TR / ROW * row_i) * velocity_i;
    pts_j_td = pts_j - (td - td_j + TR / ROW * row_j) * velocity_j;
    // 坐标变换，目的是从第i帧特征点转换到第j帧
    Eigen::Vector3d pts_camera_i = pts_i_td / inv_dep_i; // 转换到第i帧相机坐标系
    Eigen::Vector3d pts_imu_i = qic * pts_camera_i + tic; // 转换到第i帧IMU坐标系
    Eigen::Vector3d pts_w = Qi * pts_imu_i + Pi; // 转换到世界坐标系
    Eigen::Vector3d pts_imu_j = Qj.inverse() * (pts_w - Pj); // 转换到第j帧IMU坐标系
    Eigen::Vector3d pts_camera_j = qic.inverse() * (pts_imu_j - tic); // 转换到第j帧相机坐标系
    Eigen::Map residual(residuals);

#ifdef UNIT_SPHERE_ERROR 
    residual =  tangent_base * (pts_camera_j.normalized() - pts_j_td.normalized()); //论文中的重投影误差
#else
    double dep_j = pts_camera_j.z();
    residual = (pts_camera_j / dep_j).head<2>() - pts_j_td.head<2>(); // 重投影误差
#endif

    residual = sqrt_info * residual;

    if (jacobians)
    {
        Eigen::Matrix3d Ri = Qi.toRotationMatrix();
        Eigen::Matrix3d Rj = Qj.toRotationMatrix();
        Eigen::Matrix3d ric = qic.toRotationMatrix();
        Eigen::Matrix reduce(2, 3);
#ifdef UNIT_SPHERE_ERROR
        double norm = pts_camera_j.norm();
        Eigen::Matrix3d norm_jaco;
        double x1, x2, x3;
        x1 = pts_camera_j(0);
        x2 = pts_camera_j(1);
        x3 = pts_camera_j(2);
        norm_jaco << 1.0 / norm - x1 * x1 / pow(norm, 3), - x1 * x2 / pow(norm, 3),            - x1 * x3 / pow(norm, 3),
                     - x1 * x2 / pow(norm, 3),            1.0 / norm - x2 * x2 / pow(norm, 3), - x2 * x3 / pow(norm, 3),
                     - x1 * x3 / pow(norm, 3),            - x2 * x3 / pow(norm, 3),            1.0 / norm - x3 * x3 / pow(norm, 3);
        reduce = tangent_base * norm_jaco;
#else
        reduce << 1. / dep_j, 0, -pts_camera_j(0) / (dep_j * dep_j),
            0, 1. / dep_j, -pts_camera_j(1) / (dep_j * dep_j);
#endif
        reduce = sqrt_info * reduce;

        if (jacobians[0])
        {
            Eigen::Map> jacobian_pose_i(jacobians[0]);

            Eigen::Matrix jaco_i;
            jaco_i.leftCols<3>() = ric.transpose() * Rj.transpose(); // 对应公式4
            jaco_i.rightCols<3>() = ric.transpose() * Rj.transpose() * Ri * -Utility::skewSymmetric(pts_imu_i); // 对应公式6

            jacobian_pose_i.leftCols<6>() = reduce * jaco_i;
            jacobian_pose_i.rightCols<1>().setZero();
        }

        if (jacobians[1])
        {
            Eigen::Map> jacobian_pose_j(jacobians[1]);

            Eigen::Matrix jaco_j;
            jaco_j.leftCols<3>() = ric.transpose() * -Rj.transpose(); // 对应公式5
            jaco_j.rightCols<3>() = ric.transpose() * Utility::skewSymmetric(pts_imu_j);// 对应公式7

            jacobian_pose_j.leftCols<6>() = reduce * jaco_j;
            jacobian_pose_j.rightCols<1>().setZero();
        }
        if (jacobians[2])
        {
            Eigen::Map> jacobian_ex_pose(jacobians[2]);
            Eigen::Matrix jaco_ex;
            jaco_ex.leftCols<3>() = ric.transpose() * (Rj.transpose() * Ri - Eigen::Matrix3d::Identity()); // 对应公式8
            Eigen::Matrix3d tmp_r = ric.transpose() * Rj.transpose() * Ri * ric;
            jaco_ex.rightCols<3>() = -tmp_r * Utility::skewSymmetric(pts_camera_i) + Utility::skewSymmetric(tmp_r * pts_camera_i) +
                                     Utility::skewSymmetric(ric.transpose() * (Rj.transpose() * (Ri * tic + Pi - Pj) - tic)); // 对应公式9
            jacobian_ex_pose.leftCols<6>() = reduce * jaco_ex;
            jacobian_ex_pose.rightCols<1>().setZero();
        }
        if (jacobians[3])
        {
            Eigen::Map jacobian_feature(jacobians[3]);
            jacobian_feature = reduce * ric.transpose() * Rj.transpose() * Ri * ric * pts_i_td * -1.0 / (inv_dep_i * inv_dep_i); // 对应公式10
        }
        if (jacobians[4])
        {
            Eigen::Map jacobian_td(jacobians[4]);
            jacobian_td = reduce * ric.transpose() * Rj.transpose() * Ri * ric * velocity_i / inv_dep_i * -1.0  +
                          sqrt_info * velocity_j.head(2); // 对应公式22
        }
    }
    sum_t += tic_toc.toc();

    return true;
}

预积分因子

以下代码中的公式对应这篇文章VINS系列：(二)IMU预积分详细推导_Derrr...的博客-CSDN博客

virtual bool Evaluate(double const *const *parameters, double *residuals, double **jacobians) const
    {
        // 取出优化变量
        Eigen::Vector3d Pi(parameters[0][0], parameters[0][1], parameters[0][2]);
        Eigen::Quaterniond Qi(parameters[0][6], parameters[0][3], parameters[0][4], parameters[0][5]);

        Eigen::Vector3d Vi(parameters[1][0], parameters[1][1], parameters[1][2]);
        Eigen::Vector3d Bai(parameters[1][3], parameters[1][4], parameters[1][5]);
        Eigen::Vector3d Bgi(parameters[1][6], parameters[1][7], parameters[1][8]);

        Eigen::Vector3d Pj(parameters[2][0], parameters[2][1], parameters[2][2]);
        Eigen::Quaterniond Qj(parameters[2][6], parameters[2][3], parameters[2][4], parameters[2][5]);

        Eigen::Vector3d Vj(parameters[3][0], parameters[3][1], parameters[3][2]);
        Eigen::Vector3d Baj(parameters[3][3], parameters[3][4], parameters[3][5]);
        Eigen::Vector3d Bgj(parameters[3][6], parameters[3][7], parameters[3][8]);

#if 0
        if ((Bai - pre_integration->linearized_ba).norm() > 0.10 ||
            (Bgi - pre_integration->linearized_bg).norm() > 0.01)
        {
            pre_integration->repropagate(Bai, Bgi);
        }
#endif
        // 构建IMU残差residual
        Eigen::Map> residual(residuals);
        residual = pre_integration->evaluate(Pi, Qi, Vi, Bai, Bgi,
                                            Pj, Qj, Vj, Baj, Bgj);

        // LLT分解，residual 还需乘以信息矩阵的sqrt_info
        // 因为优化函数其实是d=r^T P^-1 r ，P表示协方差，而ceres只接受最小二乘优化
        // 因此需要把P^-1做LLT分解，使d=(L^T r)^T (L^T r) = r'^T r
        Eigen::Matrix sqrt_info = Eigen::LLT>(pre_integration->covariance.inverse()).matrixL().transpose();
        residual = sqrt_info * residual;

        if (jacobians)
        {
            // 获取预积分的误差递推函数中pqv关于ba、bg的Jacobian
            double sum_dt = pre_integration->sum_dt;
            Eigen::Matrix3d dp_dba = pre_integration->jacobian.template block<3, 3>(O_P, O_BA);
            Eigen::Matrix3d dp_dbg = pre_integration->jacobian.template block<3, 3>(O_P, O_BG);

            Eigen::Matrix3d dq_dbg = pre_integration->jacobian.template block<3, 3>(O_R, O_BG);

            Eigen::Matrix3d dv_dba = pre_integration->jacobian.template block<3, 3>(O_V, O_BA);
            Eigen::Matrix3d dv_dbg = pre_integration->jacobian.template block<3, 3>(O_V, O_BG);

            if (pre_integration->jacobian.maxCoeff() > 1e8 || pre_integration->jacobian.minCoeff() < -1e8)
            {
                ROS_WARN("numerical unstable in preintegration");
                //std::cout << pre_integration->jacobian << std::endl;
///                ROS_BREAK();
            }

            // 第i帧的IMU位姿 pbi、qbi
            if (jacobians[0])
            {
                Eigen::Map> jacobian_pose_i(jacobians[0]);
                jacobian_pose_i.setZero();

                jacobian_pose_i.block<3, 3>(O_P, O_P) = -Qi.inverse().toRotationMatrix(); // 对应公式(17)
                jacobian_pose_i.block<3, 3>(O_P, O_R) = Utility::skewSymmetric(Qi.inverse() * (0.5 * G * sum_dt * sum_dt + Pj - Pi - Vi * sum_dt)); // 对应公式(21)

#if 0
            jacobian_pose_i.block<3, 3>(O_R, O_R) = -(Qj.inverse() * Qi).toRotationMatrix();
#else
                Eigen::Quaterniond corrected_delta_q = pre_integration->delta_q * Utility::deltaQ(dq_dbg * (Bgi - pre_integration->linearized_bg));
                jacobian_pose_i.block<3, 3>(O_R, O_R) = -(Utility::Qleft(Qj.inverse() * Qi) * Utility::Qright(corrected_delta_q)).bottomRightCorner<3, 3>(); // 对应公式(32)
#endif

                jacobian_pose_i.block<3, 3>(O_V, O_R) = Utility::skewSymmetric(Qi.inverse() * (G * sum_dt + Vj - Vi)); // 对应公式(27)

                jacobian_pose_i = sqrt_info * jacobian_pose_i;

                if (jacobian_pose_i.maxCoeff() > 1e8 || jacobian_pose_i.minCoeff() < -1e8)
                {
                    ROS_WARN("numerical unstable in preintegration");
                    
                }
            }
            // 第i帧的imu速度vbi、bai、bgi
            if (jacobians[1])
            {
                Eigen::Map> jacobian_speedbias_i(jacobians[1]);
                jacobian_speedbias_i.setZero();
                jacobian_speedbias_i.block<3, 3>(O_P, O_V - O_V) = -Qi.inverse().toRotationMatrix() * sum_dt; // 对应公式(19)
                jacobian_speedbias_i.block<3, 3>(O_P, O_BA - O_V) = -dp_dba; // 对应公式(22)
                jacobian_speedbias_i.block<3, 3>(O_P, O_BG - O_V) = -dp_dbg; // 对应公式(23)

#if 0
            jacobian_speedbias_i.block<3, 3>(O_R, O_BG - O_V) = -dq_dbg; 
#else
                
                jacobian_speedbias_i.block<3, 3>(O_R, O_BG - O_V) = -Utility::Qleft(Qj.inverse() * Qi * pre_integration->delta_q).bottomRightCorner<3, 3>() * dq_dbg; // 对应公式(35)
#endif

                jacobian_speedbias_i.block<3, 3>(O_V, O_V - O_V) = -Qi.inverse().toRotationMatrix(); // 对应公式(25)
                jacobian_speedbias_i.block<3, 3>(O_V, O_BA - O_V) = -dv_dba; // 对应公式(30)
                jacobian_speedbias_i.block<3, 3>(O_V, O_BG - O_V) = -dv_dbg; // 对应公式(29)

                jacobian_speedbias_i.block<3, 3>(O_BA, O_BA - O_V) = -Eigen::Matrix3d::Identity();

                jacobian_speedbias_i.block<3, 3>(O_BG, O_BG - O_V) = -Eigen::Matrix3d::Identity();

                jacobian_speedbias_i = sqrt_info * jacobian_speedbias_i;

            }
            // 第j帧的IMU位姿 pbj、qbj
            if (jacobians[2])
            {
                Eigen::Map> jacobian_pose_j(jacobians[2]);
                jacobian_pose_j.setZero();

                jacobian_pose_j.block<3, 3>(O_P, O_P) = Qi.inverse().toRotationMatrix(); // 对应公式(18)

#if 0
            jacobian_pose_j.block<3, 3>(O_R, O_R) = Eigen::Matrix3d::Identity();
#else
                Eigen::Quaterniond corrected_delta_q = pre_integration->delta_q * Utility::deltaQ(dq_dbg * (Bgi - pre_integration->linearized_bg));
                jacobian_pose_j.block<3, 3>(O_R, O_R) = Utility::Qleft(corrected_delta_q.inverse() * Qi.inverse() * Qj).bottomRightCorner<3, 3>(); // 对应公式(33)
#endif

                jacobian_pose_j = sqrt_info * jacobian_pose_j;

            }
            // 第j帧的IMU速度vbj、baj、bgj
            if (jacobians[3])
            {
                Eigen::Map> jacobian_speedbias_j(jacobians[3]);
                jacobian_speedbias_j.setZero();

                jacobian_speedbias_j.block<3, 3>(O_V, O_V - O_V) = Qi.inverse().toRotationMatrix(); // 对应公式(26)

                jacobian_speedbias_j.block<3, 3>(O_BA, O_BA - O_V) = Eigen::Matrix3d::Identity();

                jacobian_speedbias_j.block<3, 3>(O_BG, O_BG - O_V) = Eigen::Matrix3d::Identity();

                jacobian_speedbias_j = sqrt_info * jacobian_speedbias_j;

            }
        }

        return true;
    }

边缘化因子

bool MarginalizationFactor::Evaluate(double const *const *parameters, double *residuals, double **jacobians) const
{
    
    int n = marginalization_info->n;
    int m = marginalization_info->m;
    Eigen::VectorXd dx(n);
    for (int i = 0; i < static_cast(marginalization_info->keep_block_size.size()); i++)
    {
        int size = marginalization_info->keep_block_size[i];
        int idx = marginalization_info->keep_block_idx[i] - m;
        Eigen::VectorXd x = Eigen::Map(parameters[i], size);
        Eigen::VectorXd x0 = Eigen::Map(marginalization_info->keep_block_data[i], size);
        if (size != 7)
            dx.segment(idx, size) = x - x0;
        else
        {
            dx.segment<3>(idx + 0) = x.head<3>() - x0.head<3>();
            dx.segment<3>(idx + 3) = 2.0 * Utility::positify(Eigen::Quaterniond(x0(6), x0(3), x0(4), x0(5)).inverse() * Eigen::Quaterniond(x(6), x(3), x(4), x(5))).vec();
            if (!((Eigen::Quaterniond(x0(6), x0(3), x0(4), x0(5)).inverse() * Eigen::Quaterniond(x(6), x(3), x(4), x(5))).w() >= 0))
            {
                dx.segment<3>(idx + 3) = 2.0 * -Utility::positify(Eigen::Quaterniond(x0(6), x0(3), x0(4), x0(5)).inverse() * Eigen::Quaterniond(x(6), x(3), x(4), x(5))).vec();
            }
        }
    }
    Eigen::Map(residuals, n) = marginalization_info->linearized_residuals + marginalization_info->linearized_jacobians * dx; // 对应公式(14)
    if (jacobians)
    {

        for (int i = 0; i < static_cast(marginalization_info->keep_block_size.size()); i++)
        {
            if (jacobians[i])
            {
                // 雅可比不变
                int size = marginalization_info->keep_block_size[i], local_size = marginalization_info->localSize(size);
                int idx = marginalization_info->keep_block_idx[i] - m;
                Eigen::Map> jacobian(jacobians[i], n, size);
                jacobian.setZero();
                jacobian.leftCols(local_size) = marginalization_info->linearized_jacobians.middleCols(idx, local_size);
            }
        }
    }
    return true;
}

4、反思与探讨

5、参考文献

[1] Qin T , Li P , Shen S . VINS-Mono: A Robust and Versatile Monocular Visual-Inertial State Estimator[J]. IEEE Transactions on Robotics, 2018.

[2] Sibley G , Matthies L , Sukhatme G . Sliding window filter with application to planetary landing[J]. Journal of Field Robotics, 2010, 27.

[3] Qin T, Shen S. Online Temporal Calibration for Monocular Visual-Inertial Systems[J]. arXiv preprint arXiv:1808.00692, 2018.

[4] VINS 论文推导及代码解析. 崔华坤

[5] 白话VINS-Mono之边缘化（五） - 知乎 (zhihu.com)

[6] VIO系统中IMU与相机时间偏差标定(PaperReading) - 知乎 (zhihu.com)

你可能感兴趣的:(SLAM,计算机视觉,slam,c++,opencv,自动驾驶)

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS 算法数据结构 c++
题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享 C++Leetcode 题解
题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
C++菜鸟教程 - 从入门到精通第二节 DreamByte c++
一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
C++ lambda闭包消除类成员变量 barbyQAQ c++c++java 算法
原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
tiff批量转png 诺有缸的高飞鸟 opencv 图像处理 python opencv 图像处理
目录写在前面代码完写在前面1、本文内容tiff批量转png2、平台/环境opencv,python3、转载请注明出处：https://blog.csdn.net/qq_41102371/article/details/132975023代码importnumpyasnpimportcv2importosdeffindAllFile(base):file_list=[]forroot,ds,fsin
2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题（第三大题：完善程序代码） mmz1207 c++csp
最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
《 C++ 修炼全景指南：九》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南 c++算法 stl
摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
遥感影像的切片处理 sand&wich 计算机视觉 python 图像处理
在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
20个新手学习c++必会的程序输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
C++八股 Petrichorzncu 八股总结 c++开发语言
这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】汉子萌萌哒 CCF noi 算法数据结构 c++
一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
《 C++ 修炼全景指南：十》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南 c++数据结构 stl
摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
windows下python opencv ffmpeg读取摄像头实现rtsp推流拉流图像处理大大大大大牛啊 opencv实战代码讲解视觉图像项目 windows python opencv
windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
c++ opencv4.3 sift匹配图像处理大大大大大牛啊图像处理 opencv实战代码讲解 opencv sift c++opencv4 特征点
c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
《 C++ 修炼全景指南：四》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南 C++修炼全景指南 c++list 链表 stl
本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
AI大模型的架构演进与最新发展季风泯灭的季节 AI大模型应用技术二人工智能架构
随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
c++ 内存处理函数 heeheeai c++开发语言
在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念 c++c语言开发语言青少年编程
文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
C++常见知识掌握 nfgo c++开发语言
1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
metaRTC5.0 API编程指南(一) metaRTC metaRTC c++c语言 webrtc
概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
sublime个人设置 bawangtianzun sublime text 编辑器
如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
ubuntu安装opencv最快的方法 Derek重名了
最快方法，当然不能太多文字$sudoapt-getinstallpython-opencv借助python就可以把ubuntu的opencv环境搞起来，非常快非常容易参考：https://docs.opencv.org/trunk/d2/de6/tutorial_py_setup_in_ubuntu.html
导致格式错误的 Lambda 代理响应的原因以及如何修复它 zqhdz米时空汇编
当人们尝试使用AWSAPIGateway和AWSLambda构建无服务器应用程序时，经常出现的一个问题是_由于配置错误而执行失败：Lambda代理响应格式错误。_没有什么比通用错误消息更糟糕的了，它们不会告诉您解决问题所需的任何内容，对吧？AWS并不是以其错误消息设计而闻名，如果甚至可以这样称呼它的话，更不用说为您提供解决问题的方法了。那么如何修复这个Lambda错误以及是什么原因造成的呢？花椒壳
未来软件市场是怎么样的？做开发的生存空间如何？ cesske 软件需求
目录前言一、未来软件市场的发展趋势二、软件开发人员的生存空间前言未来软件市场是怎么样的？做开发的生存空间如何？一、未来软件市场的发展趋势技术趋势：人工智能与机器学习：随着技术的不断成熟，人工智能将在更多领域得到应用，如智能客服、自动驾驶、智能制造等，这将极大地推动软件市场的增长。云计算与大数据：云计算服务将继续普及，大数据技术的应用也将更加广泛。企业将更加依赖云计算和大数据来优化运营、提升效率，并
Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗源码编译与开发 rust c语言 c++内存安全并发编程代码安全性能优化
目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
Spring中@Value注解，需要注意的地方无量 spring bean @Value xml
Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 1、在applicationContext.xml文件(或引用文件中)中配置properties文件 <bean id="appProperty" class="org.springframework.beans.fac
mongoDB 分片开窍的石头 mongodb
mongoDB的分片。要mongos查询数据时候先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。第一步启动两台以上的mongo服务 &nb
OVER(PARTITION BY)函数用法 0624chenhong oracle
这篇写得很好，引自 http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html OVER(PARTITION BY)函数用法 2010年10月26日 OVER(PARTITION BY)函数介绍开窗函数 &nb
Android开发中，ADB server didn't ACK 解决方法一炮送你回车库 Android开发
首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 &nb
canvas中的像素绘制问题换个号韩国红果果 JavaScript canvas
pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 2.如果绘制点为一个像素的
编码乱码问题灵静志远 java jvm jsp 编码
1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 3、getBytes()、getByte
java 求几个月后的日期 darkranger calendar getinstance
Date plandate = planDate.toDate(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(plandate); // 取得三个月后时间 cal.add(Calendar.M
数据库设计的三大范式（通俗易懂） aijuans 数据库复习
关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
想学工作流怎么入手 atongyeye jbpm
工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。系统学习工作流，很重要的一本书《JBPM工作流开发指南》。本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 1 首先要
Context和SQLiteOpenHelper创建数据库百合不是茶 android Context创建数据库
一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 一:SQLiteOpenHelper创建数据库: 1,SQLi
浅谈group by和distinct bijian1013 oracle 数据库 group by distinct
group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。譬如：统计每id数并且只显示数大于3 select id ,count(id) from ta
vi opertion 征客丶 mac opration vi
进入 command mode （命令行模式）按 esc 键再按 shift + 冒号注：以下命令中带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】一、文件操作 1.1、强制退出不保存 $ q! 1.2、保存 $ w 1.3、保存并退出 $ wq 1.4、刷新或重新加载已打开的文件 $ e 二、光标移动 2.1、跳到指定行数字
【Spark十四】深入Spark RDD第三部分RDD基本API bit1129 spark
对于K/V类型的RDD,如下操作是什么含义？ val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5)) rdd.reduceByKey(_+_).collect reduceByKey在这里的操作，是把
java类加载机制 BlueSkator java 虚拟机
java类加载机制 1.java类加载器的树状结构引导类加载器 ^ | 扩展类加载器 ^ | 系统类加载器 java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。虚拟机区分一个Cla
动态添加文本框 BreakingBad 文本框
<script> var num=1; function AddInput() { var str=""; str+="<input
读《研磨设计模式》-代码笔记-单例模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ public class Singleton { } /* * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题 */ class LazySingleton
iOS应用打包发布常见问题 chenhbc ios iOS发布 iOS上传 iOS打包
这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
工作流复杂拓扑结构处理新思路 comsci 设计模式工作算法企业应用 OO
我们走的设计路线和国外的产品不太一样，不一样在哪里呢？国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
oracle 11g新特性Flashback data archive daizj oracle
1. 什么是flashback data archive Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。
多叉树:2-3-4树 dieslrae 树
平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 1、有一个数据项的节点总是有2个子节点(称为2-节点) 2、有两个数据项的节点总是有3个子节点(称为3-节
C语言学习七动态分配 malloc的使用 dcj3sjt126com c language malloc
/* 2013年3月15日15:16:24 malloc 就memory(内存) allocate(分配)的缩写本程序没有实际含义，只是理解使用 */ # include <stdio.h> # include <malloc.h> int main(void) { int i = 5; //分配了4个字节静态分配 int * p
Objective-C编码规范[译] dcj3sjt126com 代码规范
原文链接 : The official raywenderlich.com Objective-C style guide 原文作者 : raywenderlich.com Team 译文出自 : raywenderlich.com Objective-C编码规范译者 : Sam Lau
0.性能优化-目录 frank1234 性能优化
从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。主要内容包括：一、性能测试指标吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 http://frank1234.iteye.com/blog/2180305 二、性能测试策略生产环境相同基准测试预热等 htt
Java父类取得子类传递的泛型参数Class类型 happyqing java 泛型父类子类 Class
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import org.junit.Test; abstract class BaseDao<T> { public void getType() { //Class<E> clazz =
跟我学SpringMVC目录汇总贴、PDF下载、源码下载 jinnianshilongnian springMVC
----广告-------------------------------------------------------------- 网站核心商详页开发掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架；掌握数据库技术，表设计和索引优化，分库分表/读写分离；了解缓存技术，熟练使用如Redis/Memcached等主流技术；了解Ngin
the HTTP rewrite module requires the PCRE library 流浪鱼 rewrite
./configure: error: the HTTP rewrite module requires the PCRE library. 模块依赖性Nginx需要依赖下面3个包 1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 3. s
第12章 Ajax（中） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Optimize query with Query Stripping in Web Intelligence blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence and a very straightfoward video http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
Java开发者写SQL时常犯的10个错误 tomcat_oracle java sql
1、不用PreparedStatements 　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：　　他们对PreparedStatements不了解　　他们认为使用PreparedStatements太慢了　　他们认为写Prepar
世纪互联与结盟有感阿尔萨斯
10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟