Fan's Farm

Derivation of Jacobians in g2o::EdgeSE3Expmap

Fri, 19 Jun 2020 01:00:00 +0000

I has been asked about how to derive the Jacobians in g2o::EdgeSE3Expmap. Here is my derivation (note that $T_i$ and $T_j$ are the state of pose $i$ and $j$, $e$ is the error function, and $\bar{T}_{ij}$ is the measurment):

\[\begin{aligned} e &= Log(T_j^{-1} \bar{T}_{ij} T_i) \\ e(\delta \xi_i) &= Log(T_j^{-1} \bar{T}_{ij} Exp(\delta \xi_i) T_i) \\ &= Log(T_j^{-1} \bar{T}_{ij} Exp(\delta \xi_i) (T_j^{-1} \bar{T}_{ij})^{-1}T_j^{-1} \bar{T}_{ij} T_i) \\ &= Log(Exp(Adj( T_j^{-1} \bar{T}_{ij}) \delta \xi_i ) T_j^{-1} \bar{T}_{ij} T_i) \\ &= Log(Exp(Adj( T_j^{-1} \bar{T}_{ij}) \delta \xi_i ) Exp(e)) \\ &= Adj( T_j^{-1} \bar{T}_{ij}) \delta \xi_i + e \\ \frac{\partial e}{\partial \delta \xi_i} &= Adj( T_j^{-1} \bar{T}_{ij}) \\ e(\delta \xi_j) &= Log(T_j^{-1} Exp(-\delta \xi_j) \bar{T}_{ij}T_i) \\ &= Log(T_j^{-1}\bar{T}_{ij} T_i \, (\bar{T}_{ij}T_i)^{-1} Exp(-\delta \xi_j) \bar{T}_{ij}T_i) \\ &= Log(Exp(e) \, T_i^{-1}\bar{T}_{ij}^{-1} Exp(-\delta \xi_j) (T_i^{-1}\bar{T}_{ij}^{-1})^{-1}) \\ &= Log(Exp(e) Exp(- Adj(T_i^{-1}\bar{T}_{ij}^{-1})\delta \xi_j)) \\ &= e - Adj(T_i^{-1}\bar{T}_{ij}^{-1})\delta \xi_j\\ \frac{\partial e}{\partial \delta \xi_j} &= - Adj(T_i^{-1}\bar{T}_{ij}^{-1}) \end{aligned}\]

理解 C++ 右值引用和 std::move

Sat, 19 Oct 2019 01:00:00 +0000

凡有名者，皆为左值。——无求备叟

不知道 C++ 右值引用的读者，推荐阅读如何评价 C++11 的右值引用（Rvalue reference）特性？ - Tinro的回答 - 知乎.

std::move 只是尝试把一个左值临时性地 cast 成右值，本身不发生任何移动。cast 是可能失败的，比如尝试 cast 一个 const 值，这时 move 等于啥也没干。

真正的移动发生在何时呢？发生在把一个右值使用拷贝函数或赋值操作符赋值给另一个左值的时候。

string a = "hello";
string b = move(a); 
// move(a) 并没有移动，真正的移动发生在 b = move(a) 

同时，值得注意的是，一个变量名本身永远是左值，所以即使你声明了一个右值引用如 string&& a，后面用到 a 的时候 a 还是左值，如果你想把 a 移动到 b，仍需要用 move 把它临时性地变成右值：b=move(a)。注意，右值一定是没有变量名的，这个例子里只有 move(a) 才是右值，a 或者 b 都是左值。这也是为什么说 move 是一种「临时性」的右值 cast，因为右值的不可名性决定了它不可能不是临时的。

右值引用的声明一般出现在函数形参里，这样它既可以接收右值，也可以按引用接受经过 move 临时变成右值的左值。

函数形参列表里的 string && a, 正确解读应该是：接收右值，按引用传递。同理，string& 就是接收左值，按引用传递。如果没有&号那自然就是按值传递了。

注意，这里说的左值右值是针对外面传进来的那个值而言的，a 在函数内部一定是左值。「凡有名者，皆为左值」。

Vim 调试：termdebug 入门

Mon, 28 May 2018 01:00:00 +0000

简介

termdebug 是从 Vim 8.1 开始内置的调试插件，仅支持 GDB。

本教程仅在 Linux 下（Ubuntu 16.04）测试通过。

安装

将 Vim 升级至 8.1 或以上版本。

GDB 需升级至 7.12 或以上版本。

启动

默认情况下需手动加载 termdebug 插件：

:packadd termdebug

假设我们有一个简单的 helloworld.cpp 文件：

#include <iostream>

using namespace std;

int main() {
    cout << "hello world" << endl;
    int in;
    cin >> in;
    cout << "you input " << in << endl;
    return 0;
}

我们将其编译为二进制文件 helloworld：

g++ -g helloworld.cpp -o helloworld

现在，我们在 Vim 中启动 termdebug 来调试这个程序：

:Termdebug helloworld

这时 termdebug 会为我们开三个窗口。其中， GDB 窗口提供 GDB 原生操作；程序窗口供被调试程序使用，提供 IO 功能；源码窗口提供源码交互。在 GUI 版本的 Vim （如 gvim）中，源码窗口还提供交互按钮：

我们可以通过 <Ctrl-W> 按键切换不同窗口。

调试程序

我们既可以在 GDB 窗口中调试，也可以在源码窗口中调试。 GDB 调试常用指令：

- file bin   加载名为 bin 的二进制文件 
- CTRL-C     中断程序
- run/r      运行
- next/n     执行当前行，停在下一行 （step over）
- step/s     执行当前行，进入下一层函数 （step in）
- finish     执行直至离开当前函数
- where      显示栈
- continue/c 继续执行
- break/b N  在第 N 行加断点
- break/b f  在函数 f 处加断点
- delete     删除所有断点

更多 GDB 使用方法请参考官方文档： https://sourceware.org/gdb/current/onlinedocs/gdb/

在源码窗口中的调试指令：

 :Run [args]        运行程序，可带参数 [args]，或沿用上一次运行的参数
 :Arguments {args}  设置下一次运行所用参数

 :Break     在当前行加断点
 :Clear     删除当前行的一个断点

 :Step      = gdb "step" 
 :Over      = gdb "next"
 :Finish    = gdb "finish"
 :Continue  = gdb "continue"
 :Stop      中断程序

如果觉得手动输入调试指令太麻烦，可以在个人的 .vimrc 文件中自定义 keymap 来执行这些命令，如用 <F9> 来添加断点：

nnoremap <F9> :Break<CR>

现在我们来演示一下调试上面的已经加载好的 helloworld 程序：

先移动至 GDB 窗口，输入 b main 以在 main 函数入口处添加断点；
在 GDB 窗口输入 r，程序开始运行，并停在 main 函数入口；
在 GDB 窗口输入 n，程序停在 cout << "hello world" << endl; 这一行；
移动至源码窗口，输入 :Continue，程序继续运行，并在 cin >> in 处等待用户输入；
移动至程序窗口（IO窗口），输入数字 3 并回车，可以看到程序输出 you input 3，并运行直至结束；
移动至 GDB 窗口，输入 q，退出调试。

获取帮助文档

在 Vim 窗口中输入 :h terminal-debug 阅读详细的帮助文档。

四元数矩阵与 so(3) 左右雅可比

Tue, 22 May 2018 01:00:00 +0000

四元数矩阵
so(3) 雅可比
讨论
尾声
参考文献

我们知道，单位四元数 q 和 so(3) 向量 $\boldsymbol\phi$ （即 rotation vector）的对应关系为：

${\bf q}({\boldsymbol \phi}) = [ \sin\frac{\phi}{2} {\bf a}, \, \cos \frac{\phi}{2}]’$, in which $\phi = | \boldsymbol \phi|, \, {\bf a} = \frac{\boldsymbol \phi}{\phi} $

当 $\phi$ 很小时，可以近似表达为：

\[{\bf q}({\boldsymbol \phi}) = [ \frac{1}{2} {\bf \boldsymbol \phi}, \, 1]'\]

四元数小量和李代数小量有很简单的对应关系，所以在使用四元数的优化问题中，往往也取 $\delta\boldsymbol \phi$ 小量作为更新量，例如 OKVIS [1]。

具体到优化过程中，使用李群李代数（如预积分论文 [2]）和使用四元数之间还是有区别的。使用李群李代数，在 residual 推导时会用到 so3 的左雅可比或右雅可比；使用四元数，会用到四元数矩阵（或共轭四元数矩阵）。不过既然两者使用的小量一致，那四元数矩阵和 so3 的左右雅可比的关系如何呢？

之所以有这个疑问，是因为 Xingyin 兄在博客里指出 [3]，OKVIS 代码中使用了预积分，代码和预计分论文里的思路一致。不过实际上，虽然预积分流程一致，两者在雅可比推导上有所不同：预积分使用 so3 的右雅可比；OKVIS 使用四元数矩阵。所以，我们有必要把这两者的关系厘清。

四元数矩阵

两个旋转叠加，可以表达为两个四元数相乘，或者一个 4*4 矩阵与一个四元数相乘：

\[{\bf q} \otimes {\bf p} = \begin{bmatrix} q_w p_x - q_z p_y + q_y p_z + q_x p_w \\ q_z p_x + q_w p_y - q_x p_z + q_y p_w \\ -q_y p_x + q_x p_y + q_w p_z + q_z p_w \\ -q_x p_x - q_y p_y - q_z p_z + q_w p_w \\ \end{bmatrix} = {\bf Q}_l({\bf q)p} = {\bf Q}_r{\bf (p)q}\]

这里的 ${\bf Q}_l$ 为四元数矩阵， ${\bf Q}_r$ 为共轭四元数矩阵：

\[{\bf Q}_l({\bf q}) = \begin{bmatrix} q_w {\bf I}_3 + {\bf q}_{1:3}^\wedge & {\bf q}_{1:3}\\ - {\bf q}_{1:3}' & q_w \end{bmatrix} , {\bf Q}_r ({\bf q}) = \begin{bmatrix} q_w {\bf I}_3 - {\bf q}_{1:3}^\wedge & {\bf q}_{1:3}\\ - {\bf q}_{1:3}' & q_w \end{bmatrix}\]

两种矩阵对于求导非常方便：

\[\frac{\partial{\bf q \otimes p}}{\partial\bf p} = {\bf Q}_l({\bf q}), \,\frac{\partial{\bf q \otimes p}}{\partial\bf q} = {\bf Q}_r ({\bf p})\]

现在，假设有个一个待估计的旋转量 q ，其更新方式为 $\bf q \leftarrow q \otimes q(\boldsymbol\alpha)$ ， $\boldsymbol \alpha$ 为 so3 小量。假定有 q 的测量量 $\bf\tilde q$，定义误差函数 ${\bf e}_{\rm qt}$ ：

\[{\bf e}_{\rm qt} = 2( \tilde {\bf q}^{-1}\otimes {\bf q})_{1:3}\]

则其相对于更新量的雅可比为

\[\begin{aligned} \frac{\partial {\bf e}_{\rm qt}}{\partial \boldsymbol \alpha} &= 2\frac{\partial (\tilde{\bf q}^{-1}\otimes{\bf q}\otimes {\bf q}({\boldsymbol \alpha}))}{\partial \boldsymbol \alpha}\Bigg | _{(1:3, :)} \\ &=2\frac{\partial (\tilde{\bf q}^{-1}\otimes{\bf q}\otimes {\bf q}({\boldsymbol \alpha}))}{\partial {\bf q}({\boldsymbol \alpha})} \frac{\partial {\bf q}({\boldsymbol \alpha})}{\partial \boldsymbol \alpha}\Bigg | _{(1:3, :)} \\ &={\bf Q}_l(\tilde{\bf q}^{-1}\otimes{\bf q}) \begin{bmatrix} {\bf I}_3 \\ {\bf 0_{1\times 3}} \end{bmatrix}\Bigg | _{(1:3, :)} \\ &={\bf Q}_l(\tilde{\bf q}^{-1}\otimes{\bf q}) _{(1:3, 1:3)} \end{aligned}\]

即 $\frac{\partial {\bf e}_ {\rm qt}}{\partial \boldsymbol \alpha} ={\bf Q}_ l[{\bf q}({\bf e}_{\rm qt})] _{(1:3, 1:3)}$

so(3) 雅可比

据 Barfoot [4]，若 $\boldsymbol\phi$ 的左雅可比为 ${\bf J}_l({\boldsymbol \phi})$ ，右雅可比为 ${\bf J}_r({\boldsymbol \phi})$ ：

于是，假设有待估计量 C，更新方式为 ${\bf C} \leftarrow {\bf C}\, {\rm Exp}({\boldsymbol \alpha})$ ， $\boldsymbol \alpha$ 为 so3 小量。假定有 C 的测量量 $\bf\tilde C$，定义误差函数 ${\bf e}_{\rm lie}$ ：

\[{\bf e}_{\rm lie} = {\rm Log}( \tilde {\bf C}' {\bf C})\]

则其相对于更新量的雅可比为：

\[\begin{aligned} \frac{\partial {\bf e}_{\rm lie}}{\partial \boldsymbol \alpha} &= \frac{\partial{\rm Log}(\tilde{\bf C}'{\bf C} \,{\rm Exp} ({\boldsymbol \alpha}))}{\partial \boldsymbol \alpha} \\ & = {\rm J}_r({\rm Log(\tilde{\bf C}'{\bf C} )})^{-1}\\ & = {\rm J}_r({\bf e}_{\rm lie})^{-1} \end{aligned}\]

讨论

我们来比较一下 $\frac{\partial {\bf e}_ {\rm qt}}{\partial \boldsymbol \alpha}$ 和 $\frac{\partial {\bf e}_{\rm lie}}{\partial \boldsymbol \alpha}$。

首先，

\[\begin{aligned} \frac{\partial {\bf e}_ {\rm qt}}{\partial \boldsymbol \alpha} &={\bf Q}_l[{\bf q}({\bf e}_{\rm qt})] _{(1:3, 1:3)}\\ &=q_w({\bf e}_{\rm qt}) {\bf I}_3 + {\bf q}_{1:3}^\wedge({\bf e}_{\rm qt}) \end{aligned}\]

如果可以认为误差函数 ${\bf e}_{\rm qt}$ 很小，则

\[\frac{\partial {\bf e}_{\rm qt}}{\partial \boldsymbol \alpha} \approx {\bf I}_3 + \frac{1}{2}{\bf e}_{\rm qt}^\wedge\]

另一方面，据 Barfoot [4]，有

\[\frac{\partial {\bf e}_{\rm lie}}{\partial \boldsymbol \alpha} = {\rm J}_r({\bf e}_{\rm lie})^{-1} = \frac{\phi_{e}}{2}\cot\frac{\phi_{e}}{2} {\bf I}+(1-\frac{\phi_{e}}{2}\cot\frac{\phi_{e}}{2}){\bf a_{\it e}a_{\it e}}' + \frac{\phi_{e}}{2}{\bf a}_{e}^\wedge\]

如果可以认为误差函数很小，即 $\phi_{e}\rightarrow 0$ ，则 $\frac{\phi_{e}}{2}\cot\frac{\phi_{e}}{2} \rightarrow 1$ ，于是

\[\frac{\partial {\bf e}_{\rm lie}}{\partial \boldsymbol \alpha} \approx {\bf I}+\frac{\phi_{e}}{2}{\bf a}_{e}^\wedge={\bf I} + \frac{1}{2}{\bf e}_{\rm lie}^\wedge 。\]

可以看到，当可以认为误差函数很小时， $\frac{\partial {\bf e}_ {\rm qt}}{\partial \boldsymbol \alpha}$ 和 $\frac{\partial {\bf e}_ {\rm lie}}{\partial \boldsymbol \alpha}$ 是相等的。这其实很好理解，因为当 ${\bf e}_ {\rm qt} = 2( \tilde {\bf q}^{-1}\otimes {\bf q})_ {1:3} $ 很小时，${\bf q}({\boldsymbol \phi}) = [ \frac{1}{2} {\bf \boldsymbol \phi}, \, 1]’$ 估计成立，所以 ${\bf e}_ {\rm qt}, {\bf e}_{\rm lie}$ 实际上就表示同一个量，都是误差旋转量的李代数，推导出来的雅可比自然就一样了，我们只是通过不同的途径去算同一个量而已。这个例子的价值在于，展示了四元数矩阵和 so3 雅可比之间的具体关系，即：

如果有可以认为很小的 so3 量，如某个误差函数 ${\bf e}_ {\phi}$ ，则 ${\bf J}_ r({\bf e}_ {\phi})^{-1} = {\bf Q}_ l({\bf q}({\bf e}_ {\phi})) _{(1:3,1:3)}$

上面用的是右扰动模型；如果使用左扰动，可类似地得到 ${\bf J}_ l({\bf e}_ {\phi})^{-1} = {\bf Q}_ r({\bf q}({\bf e}_ {\phi}))_ {(1:3,1:3)}$ 。

尾声

如果 $\phi$ 不能认为很小，${\bf J}_ r(\boldsymbol \phi)^{-1}$ 与 ${\bf Q}_ l({\bf q}( {\boldsymbol\phi} ))$ 的关系是怎样？并不复杂。区别仅在于此时 ${\bf q}({\boldsymbol \phi}) = [ \frac{1}{2} {\bf \boldsymbol \phi}, \, 1]’$ 的估计不能成立，$ 2{\bf q}_ {1:3}$ 和 $\boldsymbol \phi$ 不能当作一个量而已；但它们之间的相互关系是已知的：${\bf q}_{1:3}= \sin\frac{|\boldsymbol\phi|}{2} \cdot \frac{\boldsymbol \phi}{|\boldsymbol\phi|}$。在上面的演算中，我们实际上得到的结果是

\[\frac{\partial\boldsymbol \phi}{\partial{\boldsymbol \alpha}}={\bf J}_r({\boldsymbol\phi})^{-1},\quad \frac{\partial{\bf q}_{1:3}}{\partial{\boldsymbol \alpha}}={\bf Q}_l({\bf q}({\boldsymbol\phi}))_{(1:3,1:3)}\]

可以证明：

\[{\bf J}_r({\boldsymbol\phi})^{-1} = \frac{\partial\boldsymbol \phi}{\partial{\bf q}_{1:3}} \,{\bf Q}_l({\bf q}({\boldsymbol\phi}))_{(1:3,1:3)}\]

代入过程就不贴了。

参考文献

[1] S. Leutenegger, S. Lynen, M. Bosse, R. Siegwart, P. Furgale, “Keyframe-based visual-inertial odometry using nonlinear optimization”, Int. Journal of Robotics Research (IJRR), 2014.

[2] C. Forster, L. Carlone, F. Dellaert and D. Scaramuzza, “On-Manifold Preintegration for Real-Time Visual–Inertial Odometry,” in IEEE Transactions on Robotics, vol. 33, no. 1, pp. 1-21, Feb. 2017.

[3] OKVIS IMU 误差公式代码版本

[4] T. Barfoot, State Estimation for Robotics.

Practical Vim: Registers

Sat, 24 Mar 2018 01:00:00 +0000

Series notes on Practical Vim by D. Neil:

Practical Vim: Modes

Practical Vim: Files

Practical Vim: Getting Around Faster

Practical Vim: Registers

Contents

Chap 10 - Copy and Paste
Chap 11 - Macros

Chap 10 - Copy and Paste

Tip 59: Delete, Yank, and Put with Unnamed Register

Delete/Yank without specifying a register will put the characters into the unnamed register.

Paste(Put) without specifying a register will put the characters from the unnamed register.

y{motion} for yank with motion.

x for deleting a character.

s for deleting a character and then into Insert mode.

d{motion} for deleting with motion.

p for pasting.

Tip 60: Grok Registers

"{reg}: address a register.

"bdd: cut the current line into register b.

"ayiw: yank the current word into register a.

"" is the unnamed register.

"0 is the Yank register, only for y{motion}.

"a-"z are the Named Registers for users to explicitly use.

"_ is the Black Hole Register, ‘eating’ anything put into it. "_d{motion} will delete the specified text without saving a copy of it.

"+ is the System Register (The X11 clipboard, used with cut, copy and paste).

"* is the Selection Register (The X11 primary, used with middle mouse button).

"= is the Expression Register, check Tip 16.

More Registers:

Register	Contents
`"%`	name of the current file
`"#`	name of the alternative file
`".`	last insert text
`":`	last Ex command
`"/`	last search pattern

Tip 61: Replace a Visual Selection with Register

On selecting some text, Put will replace it with the text in the registers. In this case, the replaced text would be put in the register (think of it as being deleted by d). This technique can be use to swap two words.

Tip 62: Paste from a Register

p P in Normal mode, <C-r> in Insert mode.

gp gP paste the same thing, but leaving the cursor at the end of pasted text instead of at the beginning.

Tip 63: Interact with the System Clipboard

In Insert mode, Ctrl-Shift-v or Ctrl-Alt-v provided by the terminal, or <C-r>+ may cause wrong indentation if autoindent is enabled. The paste option can help with this. When it is enabled, Vim turns off all Insert mode mappings and abbrevations and resets a host of options, including autoindent (look up :h 'paste').

"+p in Normal mode is better.

Chap 11 - Macros

Tip 64: Record and Execute a Macro

q{register} to begin recording a macro into a given register; q again to stop recording.

@{register} to execute the recorded contents in the specified register.

@@ repeats the macro that was invoked most recently.

Tip 65: Normalize, Strike, Abort

When executing a macro, Vim blindly repeats the sequence of canned keystrokes. Therefore,

1) Make sure the cursor is explicitly positioned where you expect (like 0,gg, etc.).

2) Strike the target with a repeatable motion: word-wise motion is better than character-wise; navigating by search can be exploited.

3) Abort when a motion fails - by default Vim aborts the rest of the macro if a motion fails, so we need not worry 100@a may over-count, and can use a very large number if we want to repeat for many times.

Tip 66: Play Back with a Count

11@{register}: execute a macro in {register} for 11 times.

Again, since Vim would abort the execution if a motion fails, so you can provide a large enough count without much worry.

Tip 67: Repeat a Change on Contiguous Lines

Record a series of operations on a line into a macro in {register}, with the last keystroke being j. Then 5@{register} would repeat the same change to the next 5 contiguous lines in series.

One problem of executing macro in series: if the executation fails in one line in the middle, it would be aborted, leaving the following lines unchanged.

Executing in parallel is a better choice in this case: use V to trigger line-wise Visual mode, select those lines, and :'<,'>normal @{register} to execute the macro on each of the lines.

Tip 68: Append Commands to a Macro

qA will record keystrokes, appending them to the existing contents of register a.

Tip 69: Act Upon a Collection of Files

Build a list of target files with :args, e.g.
```
:args *.py
```
Make sure we are at the start of the argument list:
```
:first
```
Now record a macro to reg a, while applying a series of operations.
Revert the change we have just made to the first buffer, to prevent applying the change twice on it (because we would execute the macro to ALL buffers in the argument list later):
```
:edit!
```

Execute the macro on all of the buffers in the argument list:

:argdo normal @a

This macro can also be executed in series across many files, by appending a final step that advances to the next buffer in the list (analogous to the j in the macro applied on contiguous lines) :

Keystrokes	Effect
`qA`	Begin recording new operations to append to `a`
`:next`	Advance to next buffer
`q`	Stop recording
`22@a`	Execute the macro on many buffers

Save changes to all files:
```
:wall
```

Tip 70: Evaluate an Iterator to Number Items in a List

Suppose we have this text:

partridge in a pear tree
turtle doves
French hens
calling birds
golden rings

We want it to be:

1) partridge in a pear tree
2) turtle doves
3) French hens
4) calling birds
5) golden rings

For this task we use a variable and increment it, which would look like:

:let i=0
:let i += 1

Specifically, 1) record the macro:

Keystrokes	Effect
`:let i=1`	declare the variable
`qa`	begin recording
`I<C-r>=`i`<CR>`)`<Esc>`	insert to the line beginning, getting the value of `i`
`:let i += 1`	increment `i`
`q`	stop recording

2) execute the macro:

Keystrokes	Effect
`jVG`	select all the following lines
`:'<,'>normal @a`	execute the macro in parallel

Tip 71: Edit the Contents of a Macro

The contents of a macro in a register are the very same with which the Yank/Put operations interact. So we can paste the macro contents as plain text and edit them, and then yank the contents back to the register.

Moreover, we can manipulate the text of a macro programmatically using Vim script, like

:let @a=substitute(@a, '\~', 'vU', 'g')

Look up :h substitute() for details.

OKVIS 笔记：边缘化实现

Fri, 23 Mar 2018 01:00:00 +0000

OKVIS 系列文章：

OKVIS 笔记：位姿变换及其局部参数类

OKVIS 笔记：后端状态量参数结构

OKVIS 笔记：后端架构简述

OKVIS 笔记：边缘化原理和策略

OKVIS 笔记：边缘化实现

建议阅读：

Xingyin-Fu：OKVIS 代码框架

Xingyin-Fu：OKVIS 笔记

封装结构
主要接口和函数

主要涉及源文件：

okvis_ceres/include/okvis/ceres/MarginalizationError.hpp
okvis_ceres/src/MarginalizationError.cpp
okvis_ceres/src/Estimator.cpp

封装结构

OKVIS 的边缘化在 MarginalizationError 类中实现，在 Estimator 类的 applyMarginalizationStrategy() 函数中调用。

先看看 MarginalizationError 内部封装数据：

/// @name The internal storage of the linearised system.
/// lhs and rhs: (left hand side / right hand side)
/// H_*delta_Chi = _b - H_*Delta_Chi .
/// the lhs Hessian matrix is decomposed as _H = J^T*J = _U*S*_U^T ,
/// the rhs is decomposed as _b - _H*Delta_Chi = -J^T * (-pinv(J^T) * _b + J*Delta_Chi) ,
/// i.e. we have the ceres standard form with weighted Jacobians _J,
/// an identity information matrix, and an error
/// _e = -pinv(J^T) * _b + J*Delta_Chi .
/// _e = _e0 + J*Delta_Chi .
/// @{
Eigen::MatrixXd H_;  ///< lhs - Hessian
Eigen::VectorXd b0_;  ///<  rhs constant part
Eigen::VectorXd e0_;  ///<  _e0 := pinv(J^T) * _b0
Eigen::MatrixXd J_;  ///<  Jacobian such that _J^T * J == _H
Eigen::MatrixXd U_;  ///<  H_ = _U*_S*_U^T lhs Eigen decomposition
Eigen::VectorXd S_;  ///<  singular values
Eigen::VectorXd S_sqrt_;  ///<  cwise sqrt of _S, i.e. _S_sqrt*_S_sqrt=_S; _J=_U^T*_S_sqrt
Eigen::VectorXd S_pinv_;  ///<  pseudo inverse of _S
Eigen::VectorXd S_pinv_sqrt_;  ///<  cwise sqrt of _S_pinv, i.e. pinv(J^T)=_U^T*_S_pinv_sqrt

显然，这是一个最小二乘的 H-b 系统。根据注释，大概思路如下。首先，考虑边缘化系统如下：

\[\rm H \delta \chi = b - H \Delta\chi\]

其中的 H 矩阵可以分解为 $\rm H=J^TJ=USU^T$，其中的 $\rm S$ 为奇异值矩阵（对半正定实方阵来说，奇异值和特征值相同）。于是上式可以变换为

\[\rm J^TJ \delta \chi = -J^T(-J^{T+}b+J \Delta\chi) \tag{1.1}\] \[\rm e:=-J^{T+}b+J \Delta\chi \tag{1.2}\]

此处 $()^+$ 为伪逆。于是，我们得到一个 Jacobian 为 $\rm J$，信息矩阵为单位阵，error 为 $\rm e$ 的最小二乘标准形式，可由 Ceres 来处理。

主要接口和函数

MarginalizationError::addResidualBlock()

MarginalizationError::addResidualBlock() 把一个 Residual 及其对应的 ParameterBlock 加入现有的 Marginalization 系统（即 MarginalizationError 类中封装的 H-b 系统）中，同时将其从 Map 中剔除。此后 Marginalization 系统会一直维持该 Residual 在加入 Marginalization 系统时的线性点（即 FEJ），直至其被重新线性化或从当前窗口中剔除。

代码中的重要步骤：

获取 Residual 对应的 ParameterBlock：

Map::ParameterBlockCollection parameters = mapPtr_->parameters(
      residualBlockId);

针对每一个 ParameterBlock，取其 minimalDimension 作为 additionalSize，即加入 H-b 系统时增加的行（列）数。当一个 ParameterBlock 不是 landmark 时，将其加入到 H 矩阵和 b 向量中间，即 dense 部分的尾巴上。示意如下：

| H_00         H_01 |      |  b_0  |
|       H_new       |      | b_new |
| H_01         H_11 |      |  b_1  |

上面的 H_00 和 b_0 对应原本的 dense 部分（Pose、Extrinsics、SpeedAndBias 等不是 landmark 的状态量）；H_11 b_1 对应原本的 sparse 部分（landmark 状态量）。 H_new b_new 即对应新加入的 ParameterBlock。

当一个 ParameterBlock 是 landmark 时，直接将其 append 到 H 矩阵和 b 向量的尾巴上：

| H_00  H_01        |      |  b_0  |
| H_01  H_11        |      |  b_1  |
|             H_new |      | b_new |

上述操作（为新的 ParameterBlock 在 H 和 b 中开辟相应区域）的代码为：

if(additionalSize>0) {
  if (!isLandmark) {
    // insert
    // lhs
    Eigen::MatrixXd H01 = H_.topRightCorner(denseSize, origSize - denseSize);
    Eigen::MatrixXd H10 = H_.bottomLeftCorner(origSize - denseSize, denseSize);
    Eigen::MatrixXd H11 = H_.bottomRightCorner(origSize - denseSize, origSize - denseSize);
    // rhs
    Eigen::VectorXd b1 = b0_.tail(origSize - denseSize);

    conservativeResize(H_, origSize + additionalSize, origSize + additionalSize);  // lhs
    conservativeResize(b0_, origSize + additionalSize);  // rhs

    H_.topRightCorner(denseSize, origSize - denseSize) = H01;
    H_.bottomLeftCorner(origSize - denseSize, denseSize) = H10;
    H_.bottomRightCorner(origSize - denseSize, origSize - denseSize) = H11;
    H_.block(0, denseSize, H_.rows(), additionalSize).setZero();
    H_.block(denseSize, 0, additionalSize, H_.rows()).setZero();

    b0_.tail(origSize - denseSize) = b1;
    b0_.segment(denseSize, additionalSize).setZero();
  } else {
    conservativeResize(H_, origSize + additionalSize, origSize + additionalSize);  // lhs
    conservativeResize(b0_, origSize + additionalSize);  // rhs
    // just append
    b0_.tail(additionalSize).setZero();
    H_.bottomRightCorner(H_.rows(), additionalSize).setZero();
    H_.bottomRightCorner(additionalSize, H_.rows()).setZero();
  }
}

上面的代码只是 resize，未完成计算。

接下来，先取新加的 ParameterBlock 初始值，计算 Residual 和 Jacobians：

errorInterfacePtr->EvaluateWithMinimalJacobians(parametersRaw, residualsRaw,
                                                jacobiansRaw,
                                                jacobiansMinimalRaw);

之后还会根据 loss function 去调整刚求的 residual，略过。

最后就是计算新添加的 H_new 和 b_new 了，其实很简单，就是 $\rm H=J^TJ$ 和 $\rm b=-J^Te$（以下代码有精简）：

for (size_t i = 0; i < parameters.size(); ++i) {

  ParameterBlockInfo parameterBlockInfo_i = parameterBlockInfos_.at(
      parameterBlockId2parameterBlockInfoIdx_[parameters[i].first]);

  /// 计算主对角
  H_.block(parameterBlockInfo_i.orderingIdx, parameterBlockInfo_i.orderingIdx,
           parameterBlockInfo_i.minimalDimension,
           parameterBlockInfo_i.minimalDimension) += jacobiansMinimalEigen.at(
      i).transpose().eval() * jacobiansMinimalEigen.at(i);
  b0_.segment(parameterBlockInfo_i.orderingIdx,
              parameterBlockInfo_i.minimalDimension) -= jacobiansMinimalEigen
      .at(i).transpose().eval() * residualsEigen;
  
  /// 计算右上和左下角
  for (size_t j = 0; j < i; ++j) {
    ParameterBlockInfo parameterBlockInfo_j = parameterBlockInfos_.at(
        parameterBlockId2parameterBlockInfoIdx_[parameters[j].first]);

    // upper triangular:
    H_.block(parameterBlockInfo_i.orderingIdx,
             parameterBlockInfo_j.orderingIdx,
             parameterBlockInfo_i.minimalDimension,
             parameterBlockInfo_j.minimalDimension) += jacobiansMinimalEigen
        .at(i).transpose().eval() * jacobiansMinimalEigen.at(j);
    // lower triangular:
    H_.block(parameterBlockInfo_j.orderingIdx,
             parameterBlockInfo_i.orderingIdx,
             parameterBlockInfo_j.minimalDimension,
             parameterBlockInfo_i.minimalDimension) += jacobiansMinimalEigen
        .at(j).transpose().eval() * jacobiansMinimalEigen.at(i);
  }
}

MarginalizationError::marginalizeOut()

MarginalizationError::marginalizeOut() 实现了根据 Schur Complement 来修改 H-b 系统，将给定 ParameterBlock 边缘化。

一开始是一堆整理索引值的工作，不提。

然后是计算部分。先考虑 sparse 部分（landmark）：

先对 H 和 b0 （b0 即初始的 b）进行 scale，保持计算尺度正规化
H 分解出 U 和 V，b0 分解出 b_a 和 b_b；U 和 b_a 对应不被边缘化的部分，V 和 b_b 对应将被边缘化的部分
计算 delta_b 和 delta_H（代码有精简）：
```
for (size_t i = 0; int(i) < V.cols(); i += sdim) {
  Eigen::MatrixXd M = W.block(0, i, W.rows(), sdim) * V_inv_sqrt;
  Eigen::MatrixXd M1 = W.block(0, i, W.rows(), sdim) * V_inv_sqrt*V_inv_sqrt.transpose(); 
    
  delta_H.at(idx) = delta_H.at(idx - 1) + M * M.transpose();
  delta_b.at(idx) = delta_b.at(idx - 1) + M1 * b_b.segment<sdim>(i);
}
```
我们知道在舒尔补的计算中，$\rm H_{11}$ 需要减去的量为 $\rm H_{12} H_{22}^{-1} H_{21}$，$\rm b_1$ 需要减去的量为 $\rm H_{12} H_{22}^{-1} b_{2}$。在上面的代码中，W 对应 $\rm H_{12}$，V 对应 $\rm H_{22}$，V_inv_sqrt 可以近似地理解为 $\rm H_{22}^{-1/2}$，即满足 V_inv_sqrt*V_inv_sqrt'=$\rm H_{22}^{-1}$。于是，M 就是 $\rm H_{12}H_{22}^{-1/2}$，M1 就是 $\rm H_{12}H_{22}^{-1}$。
完成舒尔补的更新：
```
b0_ -= delta_b.at(idx - 1);
H_ -= delta_H.at(idx - 1);
```
此处 b0 的更新仅对应论文中 eq(26) 的左半步。右半步则是在 EvaluateWithMinimalJacobians() 函数中完成。
最后对 H 和 b0 进行 unscale

以上是对 sparse 部分的计算。对 dense 部分的计算步骤差不多，不提。

处理完一些本地维护的信息的更新之后，将边缘化的状态量从 Map 中移除，完毕：

mapPtr_->removeParameterBlock(parameterBlockIdsCopy[i]);

MarginalizationError::updateErrorComputation()

MarginalizationError::updateErrorComputation() 这个函数比较简单，就是计算上面 (1.1) 式中的 $\rm J$, 和 (1.2) 式中的 $\rm e$ 的初始值（$\rm -J^{T+}b_0$）。这个函数需要在添加状态量（AddResidualBlock）和边缘化状态量（marginalizeOut）之后、执行优化之前调用。

先算 $\rm H=USU^T=J^TJ$ 中的 S, 及相应的 $\rm S^{-1}, S^{1/2}, S^{-1/2}$。注意，代码中的 S 及相关量都是 Vector 而非 Matrix，这是因为它们都是对角阵，取其对角元素即可：

S_ = Eigen::VectorXd(
      (saes.eigenvalues().array() > tolerance).select(
          saes.eigenvalues().array(), 0));
S_pinv_ = Eigen::VectorXd(
      (saes.eigenvalues().array() > tolerance).select(
          saes.eigenvalues().array().inverse(), 0));
S_sqrt_ = S_.cwiseSqrt();
S_pinv_sqrt_ = S_pinv_.cwiseSqrt();

于是 $\rm J=(US^{1/2})^T$：

// assign Jacobian
J_ = (p.asDiagonal() * saes.eigenvectors() * (S_sqrt_.asDiagonal())).transpose();

$\rm J^{T+}=S^{-1/2}U^{-1}=S^{-1/2}U^T$：

Eigen::MatrixXd J_pinv_T = (S_pinv_sqrt_.asDiagonal())
      * saes.eigenvectors().transpose()  *p_inv.asDiagonal();

此处多了一个 p_inv，是尺度元素，因为我们为了效果更好的特征值分解，预先对 H 做了 normalize。

最后 $\rm e_0 = -J^{T+}b_0$：

e0_ = (-J_pinv_T * b0_);

MarginalizationError::EvaluateWithMinimalJacobians()

MarginalizationError::EvaluateWithMinimalJacobians() 这个函数在 Evaluate() 中调用， Evaluate() 是 Ceres 内置虚函数，用于自定义 contraint，根据现有状态量计算 residual 误差量和 Jacobian，由 Ceres 在求解过程中自动调用。

我们需要在这里指定 MarginalizationError 的 residual 误差量和 Jacobians 计算方法。

Jacobians 我们在 updateErrorComputation() 中已经算好，绑定到输出数据即可，不提。

residual 误差量根据上面 (1.2) 式计算。首先计算估计值更新量 $\Delta \rm \chi$：

Eigen::VectorXd Delta_Chi;
computeDeltaChi(parameters, Delta_Chi);

最后计算误差量：

e = e0_ + J_ * Delta_Chi;

对于 MarginalizationError 的 H-b 系统，这相当于计算误差量，对应上面的 (1.2) 式；对于 VIO 的边缘化操作，这对应论文中 eq(26) 的右半步（左半步已经在 marginalizeOut() 中完成）。

另外，上面计算的 Jacobians 是 Minimal Jacobians，即 residual 相对于状态更新量的 Jacobians；如果还需要计算 residual 相对于状态量本身的 Jacobians，则再乘以相应的 liftJacobians 即可：

if (jacobians != NULL) {
  if (jacobians[i] != NULL) {
    /// ....
    J_i = Jmin_i * J_lift; // J_err_group = J_err_algebra * J_algebra_group
  }
}

关于这两种 Jacobians 的区别，请参考 izhengfan/ba_demo_ceres。

Estimator::applyMarginalizationStrategy()

Estimator::applyMarginalizationStrategy() 实现了边缘化策略，哪些 states 和 residuals 要 marg 掉，哪些要保留等等。整个逻辑比较烦，文字描述已经无力，下面直接贴伪代码。看起来可能有点乱，实际代码更乱。一旦真搞起这种工程逻辑，OKVIS 作者也就顾不上 OOP 了 :)

～～～～伪代码开始～～～～

Declare:

removeFrames: states to remove (frame id, or oldest keyframe id)
removeAllButPose: all in marg window (frame id)
allLinearizeFrames: all in marg window (frame id)

removeFrames contains $\rm x^{c-S}$ or $\rm x^{k_1}$. The newest one in allLinearizeFrames / removeAllButPose is $\rm x^{c-S}$. Check the strategy.

For each in removeAllButPose:

Add SpeedAndBias states to parameterBlockToBeMarg.
Add residuals concerning SpeedAndBias states to marginalizationErrorPtr. They are never ReprojectionError.

end For

For each in removeFrames:

Add Pose state to parameterBlockToBeMarg.
Get residuals concerning Pose state.
- If a residual is PoseError:
  - it is an initial pose prior, remove it from mapPtr_;
  - set reDoFixation true
  Else:
  - it must be a ReprojectionError.
  End If
Add Extrinsics state to parameterBlockToBeMarg.
- Residuals concerning Extrinsics state must be ReprojectionError.
Now let’s handle the landmarks

For each in landmarksMaps:
- Get related residuals
  
  Declare:
  - marginalize = true, indicating if this landmark should be marg
  - errorTermAdded = false
  If this landmark is connected to $\rm x^{c-S}$ or newer Frames:
  - set marginalize false
  End If
  
  If this landmark has no connected Frame in removedFrames:
  - Continue
  End If
  
  If residuals is empty:
  - Remove this landmark
  - Continue
  End If
  
  If marginalize is false:
  - Remove residuals whose related Frames are in removedFrames
  End if
  
  If marginalize:
  - Remove residuals whose related Frames are not in marg window
  - If this landmark has < 2 connected Frames in the marg window, remove residuals even if their related Frames are in marg window
  - If this landmark has >= 2 connected Frames in the marg window, and if a residual’s related Frame is in the marg window, add the ReprojectionError to marginalizationErrorPtr, and set errorTermAdded true
  End if 
  
  If after residual removal, residuals is empty:
  - Remove this landmark
  - Continue
  End If
  
  If marginalize And errorTermAdded:
  - Add this landmark to parameterBlockToBeMarg
  - Remove this landmark from landmarksMaps
  End If
End For 
Remove this Frame from statesMap_

End For

If parameterBlockToBeMarg is not empty:

marginalizationErrorPtr->marginalizeOut()
marginalizationErrorPtr->updateErrorComputation()

End If

Add marginalizationErrorPtr together with parameterBlockToBeMarg as a residual to mapPtr_

If reDoFixation:

Re-add a PoseError prior to mapPtr_

End If

～～～～伪代码结束～～～～

OKVIS 笔记：边缘化原理和策略

Thu, 22 Mar 2018 01:00:00 +0000

OKVIS 系列文章：

OKVIS 笔记：位姿变换及其局部参数类

OKVIS 笔记：后端状态量参数结构

OKVIS 笔记：后端架构简述

OKVIS 笔记：边缘化原理和策略

OKVIS 笔记：边缘化实现

建议阅读：

Xingyin-Fu：OKVIS 代码框架

Xingyin-Fu：OKVIS 笔记

边缘化原理
OKVIS 边缘化策略
参考文献

边缘化原理

边缘化在很多文献里都提到了。对于 VIO 系统来说，边缘化的目的是把旧的状态量从状态估计窗口中移除，保证运行效率；同时，需要把移除的状态量的信息保留下来，作为当下窗口的先验，尽可能避免信息丢失。边缘化主要利用的技巧是 Schur Complement（舒尔补）。这套技巧在有些不需要剔除旧变量的场合也会用到，比如 g2o 论文 [1] 中的 Systems Having Special Structure 一节，通过将高度稀疏的 landmark 部分 marginalize，先求解 dense 部分，回头再求解 landmark 部分，可以大幅提高运算速度。

下面的分析中，式子的编号将与 OKVIS 论文 [4] 中保持一致，但形式上有改动。

图优化中，状态估计总可以转换为求解一个 H-b 方程系统；将当下状态估计窗口下的 H-b 系统记为

\[\begin{bmatrix} \rm H_{11} & \rm H_{12} \\ \rm H_{21} & \rm H_{22} \end{bmatrix} \begin{bmatrix} \delta \chi_1 \\ \delta \chi_2 \end{bmatrix} = \begin{bmatrix} \rm b_1 \\ \rm b_2 \end{bmatrix} \tag{21}\]

其中，$\rm H_{11}, b_1$ 对应保留的状态量， $\rm H_{22}, b_2$ 对应需要边缘化的量。利用舒尔补，可以将边缘化的量的信息「归并到」保留量的信息中：

\[\rm H_{11}^{*} = H_{11} - H_{12}H_{22}^{-1}H_{21} \tag{22a}\] \[\rm b_{1}^{*} = b_{1} - H_{12}H_{22}^{-1}b_{2} \tag{22b}\]

于是，对于移除边缘化状态量之后的系统，只需基于 $\rm H_{11}^{\ast}$ 和 $\rm b_{1}^{\ast}$ 求解即可。

不过，为了保持系统的一致性，需要在优化迭代的过程中维持相关量的最初线性点，使用 First Estimate Jacobian （FEJ）。关于 FEJ 的原理和深入分析，请参看 [2] [3] 。简而言之，就是对于同一批状态量，未开始优化迭代时，计算其相关的 Jacobians（最初线性点）；进入优化迭代后，必须一直使用这些 Jacobians。这意味着，优化迭代过程中 H 矩阵一直不变。稍微麻烦一点的是 b 向量。因 $\rm b=-J^T\Omega e$，而误差量 $\rm e$ 受估计值 $\rm \bar{x}$ 影响，所以每一步迭代之后，$\rm \bar{x}$ 改变，b 也会改变。

OKVIS 使用一阶线性化来估计 b 的更新，避免重算 $\rm e$ 值。记最初线性点的状态估计值为 $\rm x_{0}$，到当下估计量的偏移值为 $\rm \Delta\chi$，即

\[\rm \bar{x} = Exp(\Delta \chi)\boxplus x_{0}\]

这里的 $\boxplus$ 为广义上的两个状态量的叠加，与《位姿变换及其局部参数类》文中的有所不同。于是，$\rm \bar{x}$ 时的 b 可以估计为：

\[\begin{aligned} \rm b &= \rm b_{0} + \frac{\partial \rm b}{\partial\Delta\chi}\Big|_{\rm x_0} \Delta\chi\\ &= \rm b_{0} - J^T\Omega \frac{\partial\rm e}{\partial\Delta\chi}\Big|_{\Delta\chi=0} \Delta\chi \\ &= \rm b_{0} - H\Delta\chi \tag{24} \end{aligned}\]

即

\[\begin{bmatrix} \rm b_{1} \\ \rm b_{2} \end{bmatrix} = \begin{bmatrix} \rm b_{1,0} \\ \rm b_{2,0} \end{bmatrix} - \begin{bmatrix} \rm H_{11} & \rm H_{12}\\ \rm H_{21} & \rm H_{22} \end{bmatrix} \begin{bmatrix} \Delta\chi_{1} \\ \Delta\chi_{2} \end{bmatrix} \tag{25}\]

将其代入式 (22b)，结合式 (22a)，有

\[\rm b_{1}^{\ast} = b_{1,0}-H_{12}H_{22}^{-1}b_{2,0}-H_{11}^{\ast}\Delta\chi_{1} \tag{26}\]

定义 $\rm b_{1,0}^{\ast}=b_{1,0}-H_{12}H_{22}^{-1}b_{2,0}$，$\rm b_{1,0}^{\ast}$ 在初次线性化时就可以求出。于是，边缘化过程实际上包括两个步骤：初次线性化时的式 (22a)，以及 $\rm b_{1,0}^{\ast}$；优化过程中每一步迭代后的式 (26)。其代码实现，见《边缘化实现》一文，尤其是 marginalizeOut() 和 EvaluateWithMinimalJacobians() 两个函数。

OKVIS 边缘化策略

接下来介绍 OKVIS 的边缘化策略，即状态量估计窗口管理策略。此部份 [5] 中亦有介绍。

首先，OKVIS 会维持 S 个最新 Frame 和 M 个最新 Keyframe，如下图所示。

最新的 S 个 Frame 称为 temporal window。当不断有新的 Frame 加进来，或是普通 Frame，或是 Keyframe，就需要移除掉一些 Frame 或 Keyframe，保持 S 和 M 的数目不变。

边缘化一开始时，旧的 M 个 Keyframe 都处在 marginalization window 中（marg window 中最末还有第 M+1 个 Frame，稍后可能被 marg 掉），先 marg 掉它们的 speed/Bias 项，如下图所示：

当新进来一个 Frame 时，记为 $\rm x^c$；这时，$\rm x^{c-S}$ 帧既是既有 marg window 的最后一帧，又是 temporal window 中的最先一帧；如果它不是 Keyframe，这意味着 temporal window 中的普通 Frame 多了一帧，于是 marg 掉 $\rm x^{c-S}$，如下图：

这种情况下不会有 landmark 被 marg 掉。不过，与 $\rm x^{c-S}$ 相关的 observation 需要丢掉，并且需要在 marginalization 之前丢掉，避免边缘化后的 fill-in 破坏系统中 landmark 部分的稀疏度（参看 [2]）。

如果 $\rm x^{c-S}$ 是 Keyframe，新的 Keyframe 不宜被 marg，于是就 marg 最老的一帧 Keyframe $\rm x^{k_1}$，如下图：

同时，会把被 $\rm x^{k_1}$ 观测到、且不被 $\rm x^{c-S}$ 或 $\rm x^{c-S}$ 之后的 Frame 观测到的 landmark 也 marg 掉。当然，$\rm x^{k_1}$ 对不会被 marg 的 landmark 的 observation 项也要在 marginalization 前丢掉，避免 fill-in。

当有一帧被 marg 掉，marg window 就往后扩容一帧，保持边缘化窗口大小始终一致，如上面 Fig 8、Fig 9 两图所示。

边缘化策略的代码实现，见《边缘化实现》一文，尤其是 applyMarginalizationStrategy() 函数。

参考文献

[1] R. Kümmerle, G. Grisetti, H. Strasdat, K. Konolige and W. Burgard, “G2o: A general framework for graph optimization,” 2011 IEEE International Conference on Robotics and Automation, Shanghai, 2011, pp. 3607-3613. [PDF]

[2] 白巧克力亦唯心：SLAM 中的 marginalization 和 Schur complement ↗

[3] 知乎：如何理解 SLAM 中的 First-Estimates Jacobian？↗

[4] S. Leutenegger, S. Lynen, M. Bosse, R. Siegwart, P. Furgale, “Keyframe-based visual-inertial odometry using nonlinear optimization”, Int. Journal of Robotics Research (IJRR), 2014.

[5] Xingyin-Fu：OKVIS 笔记 ↗

Practical Vim: Getting Around Faster

Tue, 20 Mar 2018 01:00:00 +0000

Series notes on Practical Vim by D. Neil:

Practical Vim: Modes

Practical Vim: Files

Practical Vim: Getting Around Faster

Practical Vim: Registers

Contents

Chap 8 - Navigate Inside Files with Motions
Chap 9 - Navigate Between Files with Jumps

Chap 8 - Navigate Inside Files with Motions

Tip 46: Keep Your Fingers on the Home Row

home row: left hand on a s d f; right hand on h j k l.

Command	Move cursor
`h`	one column left
`l`	one column right
`j`	one line down
`k`	one line up

Tip 47: Distinguish Between Real Lines and Display Lines

When the wrap setting is enabled (it’s on by default), each line that exceeds the window width will display as wrapped.

Command	Move cursor
`gj`	down one display line
`gk`	up one display line
`0`	to first character of real line
`g0`	to first character of display line
`^`	to first nonblank character of real line
`g^`	to first nonblank character of display line
`$`	to end of real line
`g$`	to end of display line

Tip 48: Move Word-Wise

Command	Move cursor
`w`	forward to start of next word
`b`	backward to previous ‘start of word’
`e`	forward to next ‘end of word’
`ge`	backward to end of previous word

ea acts like ‘append at the end of the current word’; gea acts like ‘append at the end of the previous word’.

For each of the word-wise motions, there is a WORD-wise equivalent, including W B E gE. A WORD is defined as consisting of a sequence of nonblank characters separated with whitespaces.

Tip 49: Find by Character

Command	Effect
`f{char}`	forward to the next occurrence of `{char}`
`F{char}`	backward to the previous occurrence of `{char}`
`t{char}`	forward to the character before the next occurrence of `{char}`
`T{char}`	backward to the character after the previous occurrence of `{char}`
`;`	repeat the last character-search command
`,`	reverse the last character-search command

Character search can be used like a motion, and hence can be combined with d{motion} c{motion} to finish more complicated operations.

It is better to choose target characters with a low frequency of occurrences, e.g. x z are better than e f.

Tip 50: Search to Navigate

/ to search for characters in the buffer in a forward direction; ? in a backward direction. Note that it jumps to put the cursor right at the beginning of the occurrence.

n to jump to the next occurrence by repeating the previous search; N to jump in the inverse direction.

Search can help in Visual mode to guide text selection.

Search can be combined with d{motion}.

Tip 51: Trace Selection with Precision Text Objects

Text Object	Selection
`a)` or `ab`	a pair of `(parentheses)`
`i)` or `ib`	inside of `(parentheses)`
`a}` or `aB`	a pair of `{braces}`
`i}` or `iB`	inside of `{braces}`
`a]`	a pair of `[brackets]`
`i]`	inside of `[brackets]`
`a>`	a pair of `<angle brackets>`
`i>`	inside of `<angle brackets>`
`a'`	a pair of `'single quotes'`
`i'`	inside of `'single quotes'`
`a"`	a pair of `"double quotes"`
`i"`	inside of `"double quotes"`
a`	a pair of `backticks`
i`	inside of `backticks`
`at`	a pair of `<xml>tags</xml>`
`it`	inside of `<xml>tags</xml>`

Tip 52: Delete Around, or Change Inside

Keystrokes	Buffer Contents
`iw`	current word
`aw`	current word plus one space
`iW`	current WORD
`aW`	current WORD plus one space
`is`	current sentence
`as`	current sentence plus one space
`ip`	current paragraph
`ap`	current paragraph plus one space

Tip 53: Mark Your Place and Snap Back to It

m{a-zA-Z}: marks the current cursor location with the designated letter (see :h m).

`{mark}: jump to a mark.

Automatic Marks:

Keystrokes	Buffer Contents
``	position before the last jump within current file
`.	location of last change
`^	location of last insertion
`[	start of last change or yank
`]	end of last change or yank
`<	start of last visual selection
`>	end of last visual selection

Tip 54: Jump Between Matching Parentheses

% lets us jump between opening and closing sets of parentheses (see :h %). It works with (), {}, and [].

Vim ships with a plugin matchit, which enhances the % command. When matchit is enabled, % can jump between matching pairs of keywords, like tags in HTML, class/end def/end if/end in Ruby. To enable matchit on startup:

set nocompatible
filetype plugin on
runtime macros/matchit.vim

Another good plugin is Surround.vim. Visually select some characters, and S" would surround the selection with a pair of ". S) S} work similarly. Changing existing delimiters is also possible: cs}] would change {London} to [London]. Surround.vim should be mannually installed.

Chap 9 - Navigate Between Files with Jumps

Tip 55: Traverse the Jump List

:jump: show the jump list

<C-o>: jump back

<C-i>: jump forward

Command	Effect
`[count]G`	jump to line number
//pattern`<CR>`/?pattern`<CR>`/`n`/`N`	jump to next/previous occurrence of pattern
`%`	jump to matching parentheses
`(`/`)`	jump to start of previous/next sentence
`{`/`}`	jump to start of previous/next paragraph
`H`/`M`/`L`	jump to top/middle/bottom of screen
`gf`	jump to file name under the cursor
`<C-]>`	jump to definition of keyword under the cursor
`'{mark}`/`{mark}	jump to a mark

Tip 56: Traverse the Change List

:changes: show the change list

g;: traverse backward in the change list

g,: traverse forward in the change list

`.: mark to the position of the last change

`^: mark to the position of the cursor the last time Insert mode was stopped

gi: use `^ to restore the cursor position, and then switch to Insert mode

Tip 57: Jump to the Filename Under the Cursor

gf: jump to the filename under the cursor

:set suffixesadd+=.rb: tell Vim to find filenames with .rb extension. Note that common file-type extensions are automatically handled in most modern Vim distributions.

:set path?: inspect the value of path

Tip 58: Snap Between Files Using Global Marks

m{letter}: create a mark at the current cursor position. Lowercase letters work locally in a buffer; Uppercases are global.

:vimgrep /{pattern}/ {files} can search and jump in files. Set a global mark before diving with :vimgrep.

Practical Vim: Files

Mon, 19 Mar 2018 01:00:00 +0000

Series notes on Practical Vim by D. Neil:

Practical Vim: Modes

Practical Vim: Files

Practical Vim: Getting Around Faster

Practical Vim: Registers

Contents

Chap 6 - Manage Multiple Files
Chap 7 - Open Files and Save Them to Disk

Chap 6 - Manage Multiple Files

Tip 36: Track Open Files with the Buffer List

When we are editing a file, we are actually operating on an in-memory representation of a file, named buffer.

:ls: show the buffer list.

:bnext: switch to the next buffer in the buffer list, in which the # symbol represents the alternate file.

<C-^>: toggle between the current and alternate files.

:buffer N: jump to a buffer by number.

:buffer {bufname}: jump to a buffer by name. The {bufname} need only contain enough characters from the filepath to uniquely identity the buffer.

:bufdo: allows to execute an Ex command in all of the buffers listed by :ls. In practice, :argdo may be more practical.

Deleting buffers can be in one of these forms:

:bdelete N1 N2 N3
:N,M bdelete

:bdelete can be written as :bd.

Tip 37: Group Buffers into a Collection with the Argument List

:args: provides the argument list. The argument list represents the list of files that was passed as an argument when we ran the vim command.

:args {arglist}: the {arglist} can include filenames, wildcards, or even the output from a shell command. The technique works fine if we want to add some buffers.

Specify Files by Glob

Glob	Files Matching the Expansion
`:args .`	`index.html` `app.js`
`:args */.js`	`app.js` `lib/framework.js` `app/controllers/Mailers.js` …etc
`:args */.*`	`app.js` `index.js` `lib/framework.js` `lib/theme.css` `app/controllers/Mailers.js` …etc

Specify Files by Backtick Expansion

:args `cat .chapters`: execute the text inside the backtick characters in the shell, using the output from the cat command as the argument for the :args command. Here, we get the contents of the hidden file .chapters and pass them to :args.

Use the Argument List

Argument list is simpler to manage than Buffer list.

:args {arglist} can clear and repopulate the list with a single command
:next :prev can traverse the files in the list
:argdo can execute the same command on each buffer in the arg list

Tip 38: Manage Hidden Buffers

Command	Effect
`:w[rite]`	write the contents of the buffer to disk
`:e[dit]!`	read the file from disk back into the buffer (that is, revert unsaved changes)
`:qa[ll]!`	close all windows, discarding changes without warning
`:wa[ll]`	write all modified buffers to disk

Vim does not allow going to other items in Argument list until we save the changes in the current buffer. If hidden setting is enabled, then we can use the :next :bnext :cnext commands without a trailing bang. If the active buffer is modified, Vim will automatically hide it when we navigate away from it. The hidden setting makes it possible to use :argdo and :bufdo to change a collection of buffers with a single command.

Tip 39: Divide Workspace into Split Windows

Command	Effect
`<C-w>s`	split the current window horizontally, reusing the current buffer in the new window
`<C-w>v`	split the current window vertically, reusing the current buffer in the new window
`:sp[lit] {file}`	split the current window horizontally, loading `{file}` into the new window
`:vsp[lit] {file}`	split the current window vertically, loading `{file}` into the new window

Command	Effect
`<C-w>w`	cycle between open windows
`<C-w>h`	focus the window to the left
`<C-w>j`	focus the window below
`<C-w>k`	focus the window above
`<C-w>l`	focus the window to the right

<C-w><C-w> does the same thing as <C-w>w; so as the other four in the table above.

Ex Command	Normal Command	Effect
`:cl`	`<C-w>c`	close the active window
`:on[ly]`	`<C-w>o`	keep only the active window, closing all others

Keystrokes	Buffer Contents
`<C-w>=`	equalize width and height of all windows
`<C-w>_`	maximize height of the active window
`<C-w>\|`	maximize width of the active window
`[N]<C-w>_`	set active window height to `[N]` rows
`[N]<C-w>\|`	set active window width to `[N]` columns

Tip 40: Organize Window Layouts with Tab Pages

A tab page is a container that can hold a collection of windows. Tab pages are available whether in GVim or inside a terminal. GVim draws a tab bar as part of the GUI, while in-terminal Vim draws a tab bar as a textual user interface (TUI). Tab pages, apart from the differences in appearance, are functionally identical in GUI and TUI.

:lcd {path} set the working directory locally for the current window (not for the current tab page). For a tab page containing multiple split windows, :windo lcd {path} can set the local directory for all the split windows.

Command	Effect
`:tabe[dit] {filename}`	open `{filename}` in a new tab
`<C-w>T`	move the current window into its own tab
`:tabc[lose]`	close the current tab page and all of its windows
`:tabo[nly]`	keep the active tab page, closing all others

Ex Command	Normal Command	Effect
`:tabn[ext] {N}`	`{N}gt`	switch to tab page number `{N}`
`:tabn[ext]`	`gt`	switch to next tab page
`:tabp[revious]`	`gT`	switch to previous tab page

:tabmove [N] can rearrange tab pages. When [N] is 0, the current tab page is moved to the beginning; when [N] is omitted, it is moved to the end.

Chap 7 - Open Files and Save Them to Disk

Tip 41: Open a File by `:edit`

:pwd: print working directory.

:edit {filepath}: open a file by its absolute or relative filepath.

:edit %<Tab>: the % symbol is shorthand for the filepath of the active buffer. Pressing <Tab> expands the filepath, revealing the absolute path of the active buffer.

:edit %:h<Tab>: the :h modifier removes the filename while preserving the rest of the path. So %h<Tab> will give the full path of the current file’s directory.

We can creating a mapping for the %:h expansion like

cnoremap <expr> %% getcmdtype() == ':' ? expand('%:h').'/' : '%%'

Now when we type %% on Vim’s : command-line prompt, it automatically expands to the directory path of the active buffer, just like %:h<Tab>.

Tip 42: Open a File by `:find`

The :find command allows to open a file by its name without having to provide a fully qualified path.

:set path+=app/**: set a set of directories inside of which Vim will search when the :find command is invoked. The ** wildcard matches all subdirectories beneath the app/ directory.

For the path setting, the treatment of * and ** is slightly different (see :h file-searching) from Populating the Argument List. The wildcards are handled by Vim rather than by the shell.

Tip 43: Explore the File System with netrw

netrw is a plugin, but comes as standard with the Vim distribution. The minimum requirement for .vimrc file to load plugins:

set nocompatible
filetype plugin on

$ vim .: show the contents of current directory in a regular Vim buffer. Pressing - can open the parent directory.

Ex Command	Shorthand	Effect
`:edit .`	`:e.`	open file explorer for current working directory
`:Explore`	`:E`	open file explorer for the directory of the active buffer

In addition to :Explore, :Sexplore and :Vexplore open the file explorer in a horizontal or vertical split window.

netrw can also create new files (:h netrw-%) or directories (:h netrw-d), rename existing ones (:h netrw-rename), or delete them (:h netrw-del).

netrw can even read and write files across a network, using protocols including scp ftp curl and wget. Loop up :h netrw-ref.

Tip 44: Save Files to Nonexistent Directories

Create a new file in a directory that does not exist:

:edit madeup/dir/doesnotexist.yet

Vim creates a buffer for it, but it cannot be saved directly with :w. In this case:

:!mkdir -p %:h
:write

The -p flag tells the mkdir to create intermediate directories.

Tip 45: Save Files as the Super User

Edit hosts as a common user:

$ vim /etc/hosts

Save the file without leaving Vim:

:w !sudo tee % > /dev/null

Although Vim is still running as a common user, by using :write !{cmd} we can run {cmd} in the external shell as the superuser. % in command-line mode represent the path of the current buffer. So the final part is actually sudo tee /etc/hosts/ > /dev/null. This command receives the contents of the buffer as standard input, using it to overwrite the contents of the /etc/hosts file.

The > /dev/null tail exists here because tee writes to stdout AND a file, and we want to silence stdout.

Additionally, Vim detectes that the file has been changed outside, so Vim will prompts us to choose whether to keep the version in the buffer or load the version on disk. In this case, the file and the buffer happen to have the same contents.

Practical Vim: Modes

Sat, 17 Mar 2018 01:00:00 +0000

Series notes on Practical Vim by D. Neil:

Practical Vim: Modes

Practical Vim: Files

Practical Vim: Getting Around Faster

Practical Vim: Registers

Contents

Chap 1 - The Vim Way
Chap 2 - Normal Mode
Chap 3 - Insert Mode
Chap 4 - Visual Mode
Chap 5 - Command-Line Mode

Chap 1 - The Vim Way

Tip 1: Repeat with Dot Command

.: Repeat last change

>G: indent lines until the end of file

Tip 2: Append line and repeat

A: append to the end of current line

C = c$: delete until the end of line, into Insert mode

s = cl: delete the character at right, into Insert mode

Tip 3: Forward scan and repeat

f+: forward scan line for character +

;: forward scan line for latest forward-scanned character

;.: forward scan line for latest forward-scanned character, repeat lately executed change

Tip 4: Repeat and Reverse

Intent	Act	Repeat	Reverse
make a change	{edit}	`.`	`u`
scan line for next char	`f{char}`/`t{char}`	`;`	`,`
scan line for previous char	`F{char}`/`T{char}`	`;`	`,`
scan document for next match	/pattern`<CR>`	`n`	`N`
scan document for previous match	?pattern`<CR>`	`n`	`N`
perform substitution	:s/target/replacement	`&`	`u`
execute a sequence of changes	`qx{changes}q`	`@x`	`u`

Tip 5: Find and replace by hand

*: find the next string matched to the word below cursor

n: find the next matched string searched lately, which can follow the / or * command

cw: delete to the end of the word, into Insert mode.

n.: go to next matched string searched lately, repeat the lately executed change

Tip 6: Revisit the Dot Formula

The Ideal: One Keystroke to Move, One Keystroke to Execute

Chap 2 - Normal Mode

Tip 8: Chunk Your Undos

i{insert some text}<Esc> constitutes a change that can be undone by a u stroke. Therefore, in Insert Mode, when openning a new line, try pressing <Esc>o instead of <CR> to keep the granularity in the change flow.

Special case: If we use the <Up>, <Down>, <Left>, or <Right> cursor keys while in Insert mode, a new undo chunk is created. It’s just as though we had switched back to Normal mode to move around with the h, j, k, or l commands, except that we don’t have to leave Insert mode. This also has implications on the operation of the dot command.

Tip 9: Compose Repeatable changes

aw: a word

daw: delete a whole word (this daw can be repeated as one step using .)

Tip 10: Use Counts to Do Simple Arithmetic

The <C-a> and <C-x> commands perform addition and subtraction on numbers (at or after the cursor). 18<C-a> will add 18 to the number. When run without a count, they increment by one.

Tip 11: Count vs Repeat

Repeat over Count: dw. may be better than 2dw or d2w in:

counting is tedious
it can be undone by u with one word in one step;
u and . commands have more granularity

Count over Repeat:

if you want to change 3 words to another series of characters, c3w followed by those characters would be better than dw.. and i and those characters
a clean and coherent undo history

Tip 12: Combine and Conquer

Operator + Motion = Action:

The d{motion} commands can be like

dl delete a character
daw delete a whole word
dap delete an entire paragraph

The same goes for c{motion}, y{motion}, etc. Find a complete list of operators by :h operator. Some of them are:

Trigger	Effect
`c`	change
`d`	delete
`y`	yank into register (copy)
`g~`	swap case
`gu`	make lowercase
`gU`	make uppercase
`>`	shift right
`<`	shift left
`=`	autoindent
`!`	filter {motion} lines though an external program

One more rule: invoking an operator in duplicate would act upon the current line, like

dd deletes the current line
>> indents the current line
gUgU or gUU make the current line all uppercase

Custom Operators

Check by :h :map-operator

Chap 3 - Insert Mode

Tip 13: Corrections in Insert Mode

Keystrokes	Effect
`<C-h>`	delete back one character (backspace)
`<C-w>`	delete back one word
`<C-u>`	delete back to start of line

These commands can also be used in Vim’s command line as well as in the bash shell.

Tip 14: Back to Normal Mode

Keystrokes	Effect
`<Esc>`	to Normal mode
`<C-[>`	to Normal mode
`<C-o>`	to Insert Normal mode

Insert Normal mode is s special version of Normal mode. It allows one command to execute, after which it will return to Insert mode immediately.

For example, the zz command redraws the screeen with the current line in the middle of the window. Thus, in Insert mode, <C-o>zz helps to move our input flow into the middle of the window.

Tip 15: Paste without Leaving Insert Mode

<C-r>{register} paste those in {register} in Insert mode.

<C-r><C-p>{register} is smarter, which inserts text literally and fixes any unintended indentation. But it’s a bit of handful. When pasting a register containing multiple lines of text, consider switching to Normal mode.

Tip 16: Do Calculations in Place

The expression register allows us to perform calculations directly. It is addressed by the = symbol.

In Insert mode, <C-r>=6*35<CR> will insert 210 directly in the text.

Tip 17: Insert Unusual Characters by Character Code

In Insert mode, <C-v>{code} can input the character whose address is {code}.

<C-v>u{00bf} will insert the character whose unicode address is 00bf. It should be a four-digit hexadecimal code.

ga outputs a message showing the address of the character under cursor.

Keystrokes	Effect
`<C-v>{123}`	insert character by decimal code
`<C-v>u{1234}`	insert character by hexadecimal code
`<C-v>{nondigit}`	insert nondigit literally
`<C-k>{char1}{char2}`	insert character represented by `{char1}{char2}` digraph

Tip 18: Insert Unusual Characters by Digraph

<C-k>?I: the ¿ character.

<C-k>12: the ½ character.

<C-k>>>: the » character.

<C-k>sa: the さ character.

Get help by :h digraphs-default or :h digraph-table.

Tip 19: Overwrite Existing Text with Replace Mode

In Normal mode, R triger Replace mode.

In Insert mode, the <Insert> key in common keyboards can toggle between Insert and Replace mode.

gR triggers Virtual Replace mode, which treats the tab character as though it consisted of spaces.

r gr provide the single-shot versions of Replace and Virtual Replace mode.

Chap 4 - Visual Mode

Tip 20: Grok Visual Mode

Commands that work the same as Normal mode in Visual:

h j k l to move cursor
f{char} to jump to a character
; , to repeat or reverse the jump by f{char}
search commands (together with n/N) to jump to pattern matches
c to change text and go into Insert mode (after selection)

Tip 21: Define a Visual Selection

Enable Visual mode from Normal mode

Command	Effect
`v`	enable character-wise Visual mode
`V`	enable line-wise Visual mode
`<C-v>`	enable block-wise Visual mode
`gv`	reselect the last visual selection

Switching between Visual modes

Command	Effect
`<Esc>`/`<C-[>`	switch to Normal mode
`v`/`V`/`<C-v>`	switch to Normal mode (when used from character-, line-, or block-wise Visual mode, respectively
`v`	switch to character-wise Visual mode
`V`	switch to line-wise Visual mode
`<C-v>`	switch to block-wise Visual mode
`o`	go to the other end of highlighted text

Tip 22: Repeat Line-Wise Visual Commands

To make the < > commands work properly:

:set shiftwidth=4 softtabstop=4 expandtab

Vj: select two lines

>./2>: indent the selected lines twice. If over shoot, u can undo it.

Tip 23: Prefer Operators to Visual Commands Where Possible

Suppose we have the 3 html lines below, and would like to make the 3 words inside the tags uppercase:

<a href="#">one</a>
<a href="#">two</a>
<a href="#">three</a>

Using a Visual Operator

vit to visually select inside the tag;
U to convert the selected characters to uppercase;
j. to repeat the above operations in the next line.

However, this set of commands will give such results:

<a href="#">ONE</a>
<a href="#">TWO</a>
<a href="#">THRee</a>

A repeated Visual command affects the same range of text (in this case, only three characters).

Using a Normal Operator

gUit j. j. give good results:

<a href="#">ONE</a>
<a href="#">TWO</a>
<a href="#">THREE</a>

Tip 24: Edit Tabular Data with Visual-Block Mode

Keystrokes	Meanings
`<C-v>3j`	select a vertical column in 4 lines
`x...`	delete that column; delete 3 more columns
`gv`	reselect the last visually selected column
`r\|`	replace each character in that column with `\|`
`yyp`	duplicate a line
`Vr-`	trigger line-wise Visual mode, and replace every character in that line with `-`

Tip 25: Change Columns of Text

Use Visual-Block mode to insert text into several lines simultaneously.

Keystrokes	Meanings
`<C-v>jje`	trigger Visual-Block mode, select blocks across three lines, whose width decided by the word in the 3rd line
`c`	delete the selected text; into Insert mode
{text}	insert {text}; only changes of the topmost line can be seen
`<Esc>`	back to Normal mode, changes in all lines can be seen

Tip 26: Append After a Ragged Visual Block

Visual-Block mode is not limited to rectangular regions.

Keystrokes	Meanings
`<C-v>jj$`	trigger Visual-Block mode; select across 3 lines, all until the end of lines
`A;`	append `;` in the end; only changes in the topmost line can be seen
`<Esc>`	back to Normal mode, changes in all lines can be seen

Note: in Visual-Block mode, I or A places the cursor at the start or end of the selection.

Chap 5 - Command-Line Mode

Vim traces its ancestry back to vi; vi traces its ancestry back to a line editor called ex, which is why we have Ex commands.

Tip 27: Meet Command Line

: to get into Command-Line mode.

Command	Effect
:[range]delete [x]	delete specified lines [into register x]
:[range]yank [x]	yank specified lines [into register x]
:[line]put [x]	put the text from register x after the specified line
:[range]copy {address}	copy the specified lines to below the line specified by {address}
:[range]move {address}	move the specified lines to below the line specified by {address}
:[range]join	join the specified lines
:[range]normal {commands}	execute Normal mode {commands} on each specified line
:[range]substitute/{pattern}/{string}/[flags]	replace occurrences of {pattern} with {string} on each specified line
:[range]global/{pattern}/[cmd]	execute the Ex command [cmd] on all specified lines where the {pattern} matches

<C-v> <C-k> <C-r>{register} work in Command-Line mode like in Insert mode.

Tip 28: Execute a Command on One or More Consecutive Lines

:1: specify line 1

:$: specify the last line

:2,5p: specify line 2 to line 5; and print them

:.: specify the current line

:.,$p: specify from the current line to the last line; and print them

:%: specify the all lines in the current file

:%s/Pratical/Pragmatic/: replace the first occurrence of “Practical” with “Pragmatic” on each line

We can also use visaul selection to specify lines.

:/<html>/,/<\/html>/: specify the range of lines beginning with a line containing <html> and ending with a line containing </html>.

:{address}+n: specify by the address adding with an offset.

:/<html>/+1,/<\/html>/-1: specify the range of lines, whose beginning line is one line below the line containing <html>, and whose ending line is one line above the line containing </html>.

Special addresses:

Symbol	Address
1	first line of the file
$	last line of the file
0	virtual line above the first line of the file
.	line where the cursor is placed
`'m`	line containing mark `m`
`'<`	start of visual selection
`'>`	end of visual selection
%	the entire file (shorthand for `:1,$`)

Here line 0 is useful in the :copy {address} or :move {address} commands when we want to copy or move a range of lines to the top of a file.

Tip 29: Duplicate or Move Lines Using `:t` and `:m` Commands

:copy = :co = :t. Think of it as copy TO.

Command	Effect
:t6	copy the current line to just below line 6
:t.	duplicate the current line (similar to Normal mode `yyp`
:t$	copy the current line to the end of the file
`:'<,'>t0`	copy the visually selected lines to the start of the file

:move = :m. It functions analogously to :t, but in ‘move’ rather than ‘copy’ way.

Tip 30: Run Normal Mode Command Across a Range

Use :normal to run Normal mode command on a range of lines.

:'<,'>normal .: for each line in the visual selection, execute the Normal mode dot command.

:%normal A;: append a ; at the end of every line of the file.

:%normal i//: add // in the beginning of every line of the file.

Tip 31: Repeat the Last Ex Command

@:: repeat the last ex command.

Tip 32: Tab-Complete Ex Commands

<C-d>: in Command mode, to reveal a list of possible completions

<Tab>: cycle through the possible completions

Customize the completion behaviors with the ‘wildmode’ option. :h 'wildmode' to get help.

Tip 33: Insert the Current Word at the Command Prompt

<C-r><C-w> copies the word under the cursor and inserts it at the command line prompt.

Tip 34: Recall Commands from History

Use up arrow key to get the previous command; down arrow in the opposite direction.

Arrow keys can be avoided for recalling command history, by custom mappings:

cnoremap <C-p> <Up>
cnoremap <C-n> <Down>

:write | !python %: join the commands :write and :!python %

q: in Normal mode to meet the Command-Line window.

Command	Action
`q/`	open the command-line window with history of searches
`q:`	open the command-line window with history of Ex commands
`<C-f>`	switch from Command-Line mode to the command-line window

Tip 35: Run Command in the Shell

:!python %: execute the current file using python

:shell: hang the current Vim session, into a shell interface

$ exit: exit the shell and back to Vim

If we already run Vim in Bash, <C-z> in Vim and fg in Bash achieve the same function as :shell in Vim and exit in shell.

The position of ! matters:

:write !sh: pass the contents of the buffer as input to the external sh
:write ! sh: same as above
:write! sh: write the contents of the buffer to a file called sh by calling the :write! command.

Filtering the Contents Through an External Command

Suppose we have a csv file:

first name,last name,email
john,smith,john@example.com
drew,neil,drew@vimcasts.org
jane,doe,jane@example.com

We can sort the namelist by the last name using this command:

:2,$!sort -t',' -k2

Here :2,$ specify the line range; sort is the external filtering command; the -t',' option assigns that fields are separated with commas, and the k2 flag indicates that the second field is to be used for the sort.

Command	Effect
`:shell`	start a shell (return to Vim by typing `exit`
`:!{cmd}`	execute `{cmd}` with the shell
`:read !{cmd}`	execute `{cmd}` in the shell and insert its standard output below the cursor
`:[range]write !{cmd}`	execute `{cmd}` in shell with `[range]` lines as standard input
`:[range]!{filter}`	filter the specified `[range]` through external program `{filter}`

Fan's Farm

Derivation of Jacobians in g2o::EdgeSE3Expmap

理解 C++ 右值引用和 std::move

Vim 调试：termdebug 入门

简介

安装

启动

调试程序

获取帮助文档

四元数矩阵与 so(3) 左右雅可比

四元数矩阵

so(3) 雅可比

讨论

尾声

参考文献

Practical Vim: Registers

Chap 10 - Copy and Paste

Tip 59: Delete, Yank, and Put with Unnamed Register

Tip 60: Grok Registers

Tip 61: Replace a Visual Selection with Register

Tip 62: Paste from a Register

Tip 63: Interact with the System Clipboard

Chap 11 - Macros

Tip 64: Record and Execute a Macro

Tip 65: Normalize, Strike, Abort

Tip 66: Play Back with a Count

Tip 67: Repeat a Change on Contiguous Lines

Tip 68: Append Commands to a Macro

Tip 69: Act Upon a Collection of Files

Tip 70: Evaluate an Iterator to Number Items in a List

Tip 71: Edit the Contents of a Macro

OKVIS 笔记：边缘化实现

封装结构

主要接口和函数

MarginalizationError::addResidualBlock()

MarginalizationError::marginalizeOut()

MarginalizationError::updateErrorComputation()

MarginalizationError::EvaluateWithMinimalJacobians()

Estimator::applyMarginalizationStrategy()

OKVIS 笔记：边缘化原理和策略

边缘化原理

OKVIS 边缘化策略

参考文献

Practical Vim: Getting Around Faster

Chap 8 - Navigate Inside Files with Motions

Tip 46: Keep Your Fingers on the Home Row

Tip 47: Distinguish Between Real Lines and Display Lines

Tip 48: Move Word-Wise

Tip 49: Find by Character

Tip 50: Search to Navigate

Tip 51: Trace Selection with Precision Text Objects

Tip 52: Delete Around, or Change Inside

Tip 53: Mark Your Place and Snap Back to It

Tip 54: Jump Between Matching Parentheses

Chap 9 - Navigate Between Files with Jumps

Tip 55: Traverse the Jump List

Tip 56: Traverse the Change List

Tip 57: Jump to the Filename Under the Cursor

Tip 58: Snap Between Files Using Global Marks

Practical Vim: Files

Chap 6 - Manage Multiple Files

Tip 36: Track Open Files with the Buffer List

Tip 37: Group Buffers into a Collection with the Argument List

Tip 38: Manage Hidden Buffers

Tip 39: Divide Workspace into Split Windows

Tip 40: Organize Window Layouts with Tab Pages

Chap 7 - Open Files and Save Them to Disk

Tip 41: Open a File by :edit

Tip 42: Open a File by :find

Tip 43: Explore the File System with netrw

Tip 44: Save Files to Nonexistent Directories

Tip 45: Save Files as the Super User

Practical Vim: Modes

Chap 1 - The Vim Way

Tip 1: Repeat with Dot Command

Tip 2: Append line and repeat

Tip 3: Forward scan and repeat

Tip 4: Repeat and Reverse

Tip 5: Find and replace by hand

Tip 6: Revisit the Dot Formula

Tip 41: Open a File by `:edit`

Tip 42: Open a File by `:find`

Tip 29: Duplicate or Move Lines Using `:t` and `:m` Commands