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,自动驾驶)

美团自动配送车2024春季招聘 | 社招专场美团技术团队
关于美团自动配送团队美团自动配送以自研L4级自动驾驶软硬件技术为核心，与美团即时零售业务结合，形成满足公开道路、校园、社区、工业园区等室外全场景下的自动配送整体解决方案。美团自动配送团队成立于2016年，团队成员来自于Waymo、Cruise、Pony.ai、泛亚等自动驾驶行业头部公司，自动驾驶技术团队博士占比高达30%，依靠视觉、激光等传感器，实时感知预测周围环境，通过高精地图定位和智能决策规划
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
c++中如何判断变量的数据类型，并输出 xnrbjy c++开发语言
C++中如果想要判断变量的数据类型，可以使用typeid运算符。该运算符返回一个std::type_info类型的对象，可以使用name()方法获取其名称从而确定变量的类型，例如：#include#includeusingnamespacestd;intmain(){inta=123;floatb=3.14;boolc=true;chard='A';stringe="HelloWorld";cou
C++学习笔记（lambda函数） __TAT__ C&C++c++学习笔记
C++learningnote1、lambda函数的语法2、lambda函数的几种用法1、lambda函数的语法lambda函数的一般语法如下：[capture_clause](parameters)->return_type{function_body}capture_clause：需要捕获的变量，但要求该变量必须在这个作用域中。通常的捕获方式有以下几种：[]：不捕获任何变量[&]：按引用捕获变
大创项目推荐深度学习 opencv python 公式识别(图像识别机器视觉) laafeer python
文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
标定系列——基于OpenCV实现普通相机、鱼眼相机不同标定板下的标定（五） JANGHIGH 标定 opencv
标定系列——基于OpenCV实现相机标定（五）说明代码解析VID5.xmlin_VID5.xmlcamera_calibration.cpp说明该程序可以实现多种标定板的相机标定工作代码解析VID5.xmlimages/CameraCalibration/VID5/xx1.jpgimages/CameraCalibration/VID5/xx2.jpgimages/CameraCalibratio
OpenCV 如何使用 XML 和 YAML 文件的文件输入和输出愚梦者深度学习人工智能计算机视觉 c++opencv
返回：OpenCV系列文章目录（持续更新中......）上一篇：如何利用OpenCV4.9离散傅里叶变换下一篇:目标本文内容主要介绍：如何使用YAML或XML文件打印和读取文件和OpenCV的文本条目？如何对OpenCV数据结构做同样的事情？如何为您的数据结构执行此操作？使用OpenCV数据结构，例如cv::FileStorage,cv::FileNodeorcv::FileNodeIterato
C++ pdf 打印插入图片灿烂李 java 前端服务器
一：使用PODOFO给PDF插入图片：#includeintmain(){PoDoFo::PdfMemDocumentpdfDocument;PoDoFo::PdfPage*page;PoDoFo::PdfImageimage;PoDoFo::PdfVecObjects*vec_objects;PoDoFo::PdfRectrect;//打开PDF文档pdfDocument.loadFromFil
OpenCV基础demo 苍天饶过谁？ OpenCV学习 opencv 人工智能计算机视觉 C++
一、读取图像//图片路径QStringappPath=QCoreApplication::applicationDirPath();QStringimagePath=appPath+"/sun.png";//读取图像cv::Matimg=cv::imread(imagePath.toStdString());//IMREAD_GRAYSCALE灰度图IMREAD_UNCHANGED具有透明通道if
OpenCV图像翻转和旋转苍天饶过谁？ OpenCV学习 opencv 人工智能计算机视觉 C++
QStringappPath=QCoreApplication::applicationDirPath();imagePath=appPath+"/A.jpg";img=cv::imread(imagePath.toStdString());if(img.empty())return;Matdst;flip(img,dst,0);//上下翻转imshow("flip0",dst);flip(img
OpenCV鼠标操作（画红色方框截取图像）苍天饶过谁？ OpenCV学习 opencv 计算机外设人工智能 C++
Pointsp(-1,-1);Pointep(-1,-1);Mattemp;staticvoidon_draw(intevent,intx,inty,intflags,void*user_data){Matimage=*((Mat*)user_data);if(event==EVENT_LBUTTONDOWN){sp.x=x;sp.y=y;}elseif(event==EVENT_LBUTTONU
《外观模式（极简c++）》 Bovinitwo 设计模式（极简c++版）c++开发语言
本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
opencv “未声明的标识符：SurfFeatureDetector”问题解决办法 adsdriver Opencv学习点滴 opencv 特征点检测未声明的标识符 SurfFeatur Detector
在VS中使用opencv2.4.X版本的时候，如果使用SurfFeatureDetector（或者SiftFeatureDetector）做特征点检测的时候，按照官方文档上的示例代码include头文件为：opencv2/features2d/features2d.hpp，则会出现如下报错：errorC2065:“SurfFeatureDetector”:未声明的标识符。1、实际上2.4.X版本的
OpenCV（一个C++人工智能领域重要开源基础库）简介愚梦者 OpenCV 人工智能人工智能 opencv c++图像处理计算机视觉开源
返回：OpenCV系列文章目录（持续更新中......）上一篇：OpenCV4.9.0配置选项参考下一篇：OpenCV4.9.0开源计算机视觉库安装概述引言：OpenCV（全称OpenSourceComputerVisionLibrary）是一个基于开放源代码发行的跨平台计算机视觉库，可以用来进行图像处理、计算机视觉和机器学习等领域的开发。该库由英特尔公司于1999年开始开发，最初是为了加速处理器
动态多态的注意事项 Austin_1024 动态多态静态多态虚函数子类重写父类虚函数实现动态多态
大家好：衷心希望各位点赞。您的问题请留在评论区，我会及时回答。多态的基本概念多态是C++面向对象三大特性之一（多态、继承、封装）多态分为两类：静态多态：函数重载和运算符重载属于静态多态，复用函数名。动态多态：通过派生类和虚函数实现运行时多态。静态多态和动态多态的区别：静态多态的函数地址早绑定——编译阶段确定函数地址。动态多态的函数地址晚绑定——运行阶段确定函数地址。下面通过案例讲解多态：#incl
OpenCV图像像素逻辑操作苍天饶过谁？ OpenCV学习 opencv 人工智能计算机视觉 c++
cv::Matm1=cv::Mat::zeros(Size(256,256),CV_8UC3);cv::Matm2=cv::Mat::zeros(Size(256,256),CV_8UC3);rectangle(m1,Rect(100,100,80,80),Scalar(255,255,0),-1,LINE_8,0);rectangle(m2,Rect(150,150,80,80),Scalar(
C/C++中的Static关键字 SuhyOvO C语言 C++c语言 c++
Static关键字在C和C++编程中是不可或缺的一部分，它用于定义具有持久存储期的变量和函数，以及类的静态成员。虽然它的使用相对直接，但不恰当的使用可能会导致难以调试的错误和混淆。本文将探讨static关键字的概念、作用以及在C和C++中的具体应用。文章目录第一部分：深入理解Static关键字定义和基本概念在C和C++中static的基本作用第二部分：Static在C语言中的使用静态全局变量静态局
C++进阶学习（3）类类型转换一只特立独行猪 C++的学习 c++学习
文章目录一、类类型转换1.构造函数构造2.类型转换函数一、类类型转换数据类型转换在程序编译时或在程序运行实现基本类型←→基本类型基本类型←→类类型类类型←→类类型类对象的类型转换可由两种方式说明：构造函数转换函数称为用户定义的类型转换或类类型转换，有隐式调用和显式调用方式1.构造函数构造当类ClassX具有以下形式的构造函数：说明了一种从参数arg的类型到该类类型的转换ClassX::ClassX
C++ 如何去认识模板 SuhyOvO C++c++开发语言
引言:C++模板是泛型编程的基石,允许程序员定义可与任何数据类型协作的函数和类。这种机制极大地增加了代码的灵活性和复用性,是C++最强大的特性之一。本文将深入探讨C++模板的概念、优势以及使用方法,帮助读者掌握这一重要的编程工具。文章目录模板简介模板的优势一、模板基础1.1模板的概念1.2函数模板1.3类模板二、模板进阶2.1模板的实例化2.2模板的特化2.3模板的默认参数2.4模板的嵌套三、模板
opencv 十八 python下实现0缓存掉线重连的rtsp直播流播放器摸鱼的机器猫 opencv实战 opencv python 缓存
使用opencv打开rtsp视频流时，会因为网络问题导致VideoCapture掉线；也会因为图像的后处理阶段耗时过长导致opencv缓冲区数据堆积，从而使程序无法及时处理最新的数据。为此对cv2.VideoCapture进行封装，实现0缓存掉线重连的rtsp直播流播放器，让程序能一直处理最新的数据。代码实现fromcollectionsimportdequeimportthreadingimpo
C++面试题虾仁A 面试 c++
目录一、堆和栈的区别二、C++中new、delte和malloc的区别三、什么是源对象四、C++有哪些设计模式五，你使用过C++哪些类型的指针一、堆和栈的区别特性堆栈申请方式由程序员显式申请和释放由系统自动分配和释放分配方式动态分配自动分配分配效率相对较慢，需要遍历内存链表寻找合适空间相对较快，系统直接分配内存地址不连续的内存区域连续的内存区域大小限制大小灵活，上限取决于虚拟内存大小固定，通常较小
OpenCV多边形填充与绘制苍天饶过谁？ OpenCV学习 opencv 人工智能计算机视觉 C++
Matbg=Mat::zeros(Size(512,512),CV_8UC3);Pointp1(100,100);Pointp2(350,100);Pointp3(450,280);Pointp4(320,450);Pointp5(80,400);std::vectorpts;pts.push_back(p1);pts.push_back(p2);pts.push_back(p3);pts.pus
OpenCV随机数与随机颜色绘制苍天饶过谁？ OpenCV学习 opencv 人工智能计算机视觉 C++
Matbg=Mat::zeros(Size(512,512),CV_8UC3);intw=bg.cols;inth=bg.rows;RNGrng(12345);while(true){intc=cv::waitKey(10);if(c==27){break;}intx1=rng.uniform(0,w);inty1=rng.uniform(0,h);intx2=rng.uniform(0,w);i
15届蓝桥杯备赛(3) sad_liu #sad_liu的刷题记录蓝桥杯职场和发展
文章目录15届蓝桥杯备赛(3)回溯算法组合组合总和III电话号码的字母组合组合总和组合总和II分割回文串子集子集II非递减子序列全排列全排列II贪心算法分发饼干最大子数组和买股票的最佳时机II跳跃游戏15届蓝桥杯备赛(3)提高C++程序的输入输出效率，尤其是在需要大量输入输出操作时。ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie
C++ primer 第十二章红鼻子怡宝 c++primer c++开发语言
动态分配的对象的生存期与它们在哪里创建无关，只有当显式地被释放时，这些对象才会销毁。静态内存用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存用来保存定义在函数内的非static对象。堆内存用来存储动态分配的对象。静态或栈内存中的对象由编译器自动创建和销毁，而堆内存中的对象必须显式地销毁它们。1.动态内存与智能指针运算符new在动态内存中为对象分配空间并返回一
5. C++ 局部静态变量在什么时候分配内存和初始化？九五一 C++知识 c++java jvm 开发语言数据结构
C++局部静态变量在什么时候分配内存和初始化？对于C语言的全局和静态变量，不管是否被初始化，其内存空间都是全局的；如果初始化，那么初始化发生在任何代码执行之前，属于编译期初始化。由于内置变量无须资源释放操作，仅需要回收内存空间，因此程序结束后全局内存空间被一起回收，不存在变量依赖问题，没有任何代码会再被执行！C++引入了对象，这给全局变量的管理带领新的麻烦。C++的对象必须有构造函数生成，并最终执
win7休眠、待机api WarmSword Windows api windows 休眠待机关机
win7休眠、待机api通过c++让windows进入休眠或者待机状态。xp、win7下用SetSystemPowerState函数，vista及之后的版本使用SetSuspendState函数。xp、win7:SetSystemPowerStateBOOLWINAPISetSystemPowerState(_In_BOOLfSuspend,_In_BOOLfForce);ParametersfS
【No.15】蓝桥杯动态规划上|最少硬币问题|0/1背包问题|小明的背包1|空间优化滚动数组(C++) ChoSeitaku 蓝桥杯备考蓝桥杯动态规划 c++
DP初步：状态转移与递推最少硬币问题有多个不同面值的硬币(任意面值)数量不限输入金额S，输出最少硬币组合。回顾用贪心求解硬币问题硬币面值1、2、5。支付13元，要求硬币数量最少贪心:(1)5元硬币，2个(2)2元硬币，1个(3)1元硬币，1个硬币面值1、2、4、5、6.，支付9元。贪心:(1)6元硬币，1个(2)2元硬币，1个(3)1元硬币，1个错误!答案是:5元硬币+4元硬币=2个硬币问题的正解
游戏客户客户端面经 Unity游戏开发游戏游戏开发求职程序员
C#和C++的类的区别C#List添加100个Obj和100int内存是怎么变化的重载和重写的区别，重载是怎么实现的重写是怎么实现的？虚函数表是类的还是对象的用过哪些C++的STLVector底层是怎么实现的Vector添加一百次数据内存是怎么变化Map的底层，红黑树的查询和插入的时间复杂程度，Unordermap的底层实现是什么List的底层是怎么实现的场景里面有6个玩家扮演贪吃蛇进行3v3，场
opencv | 计算轮廓的质心 DdddJMs__135 分享 opencv 人工智能计算机视觉
#include#include#include#includeusingnamespacecv;usingnamespacestd;Matsrc;Matsrc_gray;intthresh=30;intmax_thresh=255;intmain(){src=imread("2.jpg",CV_LOAD_IMAGE_COLOR);cvtColor(src,src_gray,CV_BGR2GRAY
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业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟