使用第三方win10主题|常用工具

win10自带的主题就那几个，希望能用一些好看的，但Win10原生是不支持第三方主题的，需要特别之后才可以用

需要先安装一个叫UltraUXThemePatcher的软件，下载在这里

安装时要注意，软件版本应当和系统版本基本一致，否则会出问题

  1. 右键用管理员身份运行 UltraUXThemePatcher，然后点击 Install，开启安装。

  2. 重启电脑，打开Cortana，打开创建还原点程序，这个应当是win10的新程序，应当是与VMWare的还原点类似的。打开后选C盘，先到配置里启用系统保护，然后创建。因为主题文件偶尔会出问题，所以最好有还原点。

  3. (可选)安装OldNewExplore，让Windows 10的资源管理器变成Windows 7风格（有些主题需要）

  4. 把下载的第三方主题放到C:\Windows\Resources\Themes文件夹

  5. 到 桌面-右键-个性化-主题 里面选择主题。

效果：

参考：
第三方主题
视频指导使用第三方主题

多线程 join|C++多线程

使用Windows写Boost多线程时，还需要先编译Boost源码产生库文件，我试了几次都没成功，就懒得在Windows上编程了。

在Linux上，Boost使用多线程还得用到filesystem和system模块，否则会报错，可能是thread模块用到了它们，因此cmake这样写

1
2
3
4
5
6
find_package(Boost COMPONENTS filesystem system thread REQUIRED)

add_executable(${PROJECT_NAME} "main.cpp" )
target_link_libraries(untitled  ${Boost_FILESYSTEM_LIBRARY} 
        ${Boost_SYSTEM_LIBRARY}  
        ${Boost_THREAD_LIBRARY})

头文件只需要#include <boost/thread.hpp>

对于ROS环境，库文件已经包含在${catkin_LIBRARIES}当中

join

使用join()函数时，主调线程阻塞，等待被调线程终止，然后主调线程回收被调线程资源，并继续运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void thread_1(int n)
{
    cout<<"slot1: "<<n<<endl;
}

void thread_2(int n)
{
    cout<<"slot2: "<< 2*n<<endl;
}

int main()
{
    int n = 13;
    boost::thread th_1 = boost::thread(boost::bind(&thread_1,n));
    th_1.join();
    boost::thread th_2 = boost::thread(boost::bind(&thread_2,n));
    th_2.join();

    cout<<endl<<"end"<<endl;
    return 0;
}

没有两个join()会有多种结果：

1
2
3
slot2: 26end

slot1: 13

1
2
3
slot1: end
13
slot2: 26
1
2
3
4
slot1: slot2: 13
26

end

可见几个线程的执行顺序乱套了，执行顺序是    线程1 ——线程 1的join()—— 线程2 ——线程 2的join()    才确定顺序是 线程１－线程２－主线程，如果只加一个，或者先定义两个线程，再执行两个join，线程的顺序还是不确定。

Boost教程（三）多线程|C++Boost

在Linux上，Boost使用多线程还得用到filesystem和system模块，否则会报错，可能是thread模块用到了它们，因此cmake这样写

1
2
3
4
5
6
find_package(Boost COMPONENTS filesystem system thread REQUIRED)

add_executable(${PROJECT_NAME} "main.cpp" )
target_link_libraries(untitled  ${Boost_FILESYSTEM_LIBRARY} 
        ${Boost_SYSTEM_LIBRARY}  
        ${Boost_THREAD_LIBRARY})

头文件只需要#include <boost/thread.hpp>

对于ROS环境，库文件已经包含在${catkin_LIBRARIES}当中

join

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void thread_1(int n)
{
    cout<<"slot1: "<<n<<endl;
}

void thread_2(int n)
{
    cout<<"slot2: "<< 2*n<<endl;
}

int main()
{
    int n = 13;
    boost::thread th_1 = boost::thread(boost::bind(&thread_1,n));
    th_1.join();
    boost::thread th_2 = boost::thread(boost::bind(&thread_2,n));
    th_2.join();

    cout<<endl<<"end"<<endl;
    return 0;
}

没有两个join()会有多种结果：

1
2
3
slot2: 26end

slot1: 13

1
2
3
slot1: end
13
slot2: 26
1
2
3
4
slot1: slot2: 13
26

end

可见几个线程的执行顺序乱套了，给两个线程都加join()才确定顺序是 线程１－线程２－主线程，如果只加一个，剩下两个线程的顺序还是不确定。

boost::condition

程序如下，main函数里要把上面两个线程的join交换一下，先执行线程2，这样在线程2里的随机数如果大于90，会唤醒线程1。如果先执行线程1，会一直阻塞，程序没法向下执行了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
boost::mutex mut;
boost::condition cond;
boost::mutex::scoped_lock _lock(mut);

void thread_1(int n)
{
    while(true)
    {
        cond.wait(_lock);
        cout<< "thread 1: "<<rand()%50 <<endl;
        sleep(1);
    }
}

void thread_2(int n)
{
    int m;
    while(true)
    {
        m = 50 + rand()%50;
        cout<< "thread 2: "<< m <<endl;
        if(m>90)
        {
            cond.notify_one();
            cout<<"thread 2 wake thread 1   ";
        }
        sleep(1);
    }
}

某次的测试结果：

1
2
3
4
5
6
7
thread 2: 65
thread 2: 93
thread 2 wake thread 1   thread 1: 35
thread 2: 86
thread 2: 92
thread 2 wake thread 1   thread 1: 49
thread 2: 71

Boost教程（二）文件系统|C++Boost

首先在cmake中使用Boost的filesystem模块：

1
2
3
4
5
6
find_package(Boost COMPONENTS system filesystem REQUIRED)

target_link_libraries(mytarget 
  ${Boost_FILESYSTEM_LIBRARY}
  ${Boost_SYSTEM_LIBRARY}
)

必须得加上system模块

filesystem库提供了两个头文件，一个是<boost/filesystem.hpp>，这个头文件包含主要的库内容。它提供了对文件系统的重要操作。同时它定义了一个类path，正如大家所想的，这个是一个可移植的路径表示方法，它是filesystem库的基础。

filesystem在任何时候，只要不能完成相应的任务，它都可能抛出 basic_filesystem_error异常，当然并不是总会抛出异常，因为在库编译的时候可以关闭这个功能。

路径的创建很简单，仅仅需要向类boost::filesystem::path()的构造器传递一个string

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
    filesystem::path cur_path = filesystem::current_path();
    filesystem::path parent_path = cur_path.parent_path();
    //path支持重载/运算符，这个很好用
    filesystem::path file_path = cur_path/"test";
    cout<<"curren path: "<<cur_path<<endl;
    cout<<"parent path: "<<parent_path<<endl;
    if(filesystem::exists(file_path))   // 适合判断文件的存在
        cout<<"exists test "<<endl;

    filesystem::path  filePath = "/home/user/yaml";
    cout<<fs::is_directory(filePath)<<endl;     
    cout<<fs::is_empty(filePath)<<endl;     // 判断是否为空

    // unsigned long int,  byte
    cout<<"file test size: "<<filesystem::file_size(file_path)<<endl;
//    filesystem::remove(file_path);
    filesystem::rename(file_path, cur_path/"newTest");
    
    filesystem::path p("/home/user/ost.yaml");
    if(fs::exists(p))   // Boost缺陷，若文件不存在，两函数也能正常输出
    {
        cout<<p.extension()<<endl;      // "yaml"
        cout<<p.stem()<<endl;        // 文件名，不带扩展名
    }
    // 删除文件，失败会强行结束：terminate called after throwing an instance of 'boost::filesystem::filesystem_error'   所以要用 try catch throw
    try
    {
        boost::filesystem::remove(p);
    }
    catch( const boost::exception & e )
    {
        cout<< "remove error"<<endl;
        throw;
//        return -1;
    }
    filesystem::create_directory(cur_path/"dir");
    cout<<"is dir: "<<filesystem::is_directory(cur_path/"dir")<<endl;

递归获取某文件夹中符合某扩展名的所有文件名：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
namespace fs = boost::filesystem;

std::vector<fs::path> getFileNames(fs::path p, std::string extension)
{
    std::vector<fs::path> names;

    if(!fs::is_directory(p) )
        return names;

    if(fs::is_empty(p))
        return names;

    fs::recursive_directory_iterator iter(p);       //迭代目录下的所有文件
    fs::recursive_directory_iterator end_iter;      // 只接就是end iterator
    if( !p.empty() && fs::exists(p))
    {
        for(; iter!= end_iter;iter++)
        {
            try{
                if (fs::is_directory( *iter ) )
                {
//                    std::cout<<*iter << "is dir" << std::endl;
                }
                else
                {
//                    std::cout<<iter->path().stem() <<endl;
//                    std::cout<<iter->path().extension() <<endl;
//                    std::cout << "full name: "<<*iter << endl;              
                    if(iter->path().extension() == extension)
                    {
                        names.push_back(iter->path().stem());
                    }
                }
            }
            catch ( const std::exception & ex ){
                std::cerr << ex.what() << std::endl;
                continue;
            }
        }
    }
    return names;
}

// 使用
std::vector<fs::path> names = getFileNames("/home/user/yaml", ".yaml");
if(names.empty())
{
    cout<<"It's empty or not a dir"<<endl;
    return -1;
}
else
{
    for(int i=0;i<names.size();i++)
        cout<<"name: "<<names.at(i)<<endl;
}

Git常用命令|常用工具

使用Git的大忌:

  • 没什么有价值的修改就提交，也就是没有意义的提交
  • 提交到别人的分支
  • 提交的代码又引入了新的更严重更明显的bug，也就是不如不提交。比第一条更严重，让别人也无法合并

如果git下载不成功，试试下面的代理

1
git clone https://mirror.ghproxy.com/https://github.com/stilleshan/dockerfiles

wget 和 curl 同理
1
2
wget https://mirror.ghproxy.com/https://github.com/stilleshan/dockerfiles/archive/master.zip
curl -O https://mirror.ghproxy.com/https://github.com/stilleshan/dockerfiles/archive/master.zip

在本地建立仓库到push的过程：

1
2
3
4
5
git init
git add README.md
git commit -m "first commit"
git remote add origin https://github.com/rjosodtssp/Design-Modes.git
git push -u origin master

提交会附带消息和一个哈希值，哈希值是一串包含数字和字母的随机序列。

生成公钥

单独push某文件

1
2
3
git commit test.cpp
//在vim中输入更新信息
git push origin master

删除Repository

在GitHub网站上操作，打开要删除的Repository,点 Settings

Commit message 用 emoji

初次提交示例:

1
git commit -m ":tada: Initialize Repo"

🆕 (全新) :new: 引入新功能
(闪电) :zap: 提升性能
🔖 (书签) :bookmark: 发行/版本标签
🐛 (bug) :bug: 修复 bug
(急救车) :ambulance: 重要补丁

(扳手) :wrench: 修改配置文件
(加号) :heavy_plus_sign: 增加一个依赖
➖ (减号) :heavy_minus_sign: 减少一个依赖
(备忘录) :memo: 撰写文档
(锤子) :hammer: 重大重构
🔥 (火焰) :fire: 移除代码或文件

撤销对文件的修改

对 test.cpp 修改后，打算返回上次提交的状态，使用命令:

1
git checkout -- qclipper.cpp

如果要撤销 所有文件 的修改，命令为：
1
git checkout -f

git diff ReadMe.mdown 表示在commit之前查看文件修改哪些地方， 在commit之后使用此命令无效。

避免每次提交时登录

如果我们git clone的下载代码的时候是连接的https://而不是git@git (ssh)的形式，当我们操作git pull/push到远程的时候，总是提示我们输入账号和密码才能操作成功，频繁的输入账号和密码会很麻烦。

解决办法：git bash进入你的项目目录，输入

1
git config --global credential.helper store

然后你会在你本地生成一个文本，上边记录你的账号和密码。不用关心在哪，使用上述的命令配置好之后，再操作一次git pull，然后它会提示你输入账号密码，这一次之后就不需要再次输入密码了。

在Github找到以前提交的版本

点击commits
点击红圈的标志，进入旧版本的repository，然后可以下载

Alt text

重命名文件

1
2
git mv file.cpp new_file.cpp
git push origin master

删除远程库的某文件

1
2
git rm file.cpp
git commit

从本地库中删除了，再push就可以从远程库删除

从远程仓库拉取

1
2
git init
git clone

修改commit message

  上一次的message如果需要修改，使用：git commit --amend 如果上一次的commit已经push了，那么需要强制提交 git push -f origin master

修改别人的代码

先到别人的项目上fork到自己的GitHub下，clone下来以后进行修改，push到自己的项目。

在自己的项目页面pull request，把我的修改发到对方的项目里，GitHub同时给对方发了邮件，由对方决定是否接受修改。

注意：不要在对方的项目页面clone

查看当前用户名和邮箱 

1
2
git config user.name
git config user.email

修改用户名和地址，不加global只能生效一次

1
2
git config --global user.name "your name"
git config --global user.email "your email"

打标签

Git 中的tag指向一次commit的id，通常用来给开发分支做一个标记，如标记一个版本号。

1
git tag -a v1.01 -m "Relase version 1.01"

注解：git tag 是打标签的命令，-a 是添加标签，其后要跟新标签号，-m 及后面的字符串是对该标签的注释。

gitignore

gitignore在本地仓库的根目录，执行文件屏蔽 屏蔽规则

问题累计

对git本地仓库，使用rm而不是git rm删除一个文件A后，直接commit 和 push，远程仓库仍然有A。此时已经不能再执行git rm了，所以将删除动作添加到暂存区 git add .，然后再commit 和 push
操作过程

git add 报错: fatal: in unpopulated submodule

先执行 git rm --cached . -rf，再 git add

github push 代码出现fatal: Authentication failed for

2021.8月份开始远程登录不在支持使用账户密码的方式，解决方法: 把git remote add origin https://github.com/xxx/xxx.git 换成 git remote set-url origin https://<your_token>@github.com/<USERNAME>/<REPO>.git

github获取token

cout, 类型的格式输出|C++C++ 基础

std::endl的含义

常常有 std::cout<<"test"<<std::endl，这是把test先放到标准输出流，cout会对内容进行缓冲，不会立即输出到显示器．有两种方法立即显示：加flush或endl，后者还要换行，这是在缓冲区不满时刷新．有时不加这两个关键字也能显示，是因为缓冲区满了或者长时间未输入．

precision

1
2
3
cout.precision(3);
cout<< 123.567890 <<endl;　　// 124
cout<< scientific << 123.567890 <<endl;         // 1.236e+02

precision是控制输出浮点数的精度，3表示四舍五入后得到3个有效数字．精度数字超出数字个数时，还按原来数字．

scientific表示科学计数法表示，此时精度数字是小数点位数

类型 标志
unit16_t %hu
unit32_t %u
unit64_t %llu
unit32_t %zu
unsigned int %u
long long int %lld
unit32_t %u
unit32_t %u
欧拉角，旋转矩阵，旋转向量，四元数|数学基础

欧拉角

参考欧拉角的理解

对于在三维空间里的一个参考系，任何坐标系的取向，都可以用三个欧拉角来表现。参考系又称为实验室参考系，是静止不动的，而刚体坐标系则固定于刚体，随着刚体的旋转而旋转。

规定：XYZ坐标轴是旋转的刚体坐标轴；而xyz坐标轴是静止不动的实验室参考轴。

坐标系XYZ原与参考系xyz重合，旋转后，称xy平面与XY平面的交线为交点线，用英文字母N代表。zXZ顺规的欧拉角可以静态地定义如下：

  • α是x轴与交点线的夹角；

  • β是z轴与Z轴的夹角；

  • γ是交点线与X轴的夹角。


第一绕z轴旋转α，第二绕交点线（即X轴旋转后的轴）旋转β，第三绕Z轴旋转γ. 因此，此过程可分解为三个基本的旋转，从左到右依次代表绕着z轴的旋转、绕着交点线的旋转、绕着Z轴的旋转。即其旋转矩阵为

对于欧拉角，我们规定任何两个连续的旋转，必须是绕着不同的转动轴旋转。因此，一共有 12=3x2x2 种顺规。第一次旋转可以绕三个坐标轴中的任意一轴转动，有3种情况，第二次旋转可以绕除第一次旋转轴外的任意一轴转动，有2种情况，第三次旋转可以绕除第二次旋转轴外的任意一轴转动，有2种情况。

  • 经典欧拉角：z-x-z, x-y-x, y-z-y, z-y-z, x-z-x, y-x-y

  • 泰特-布莱恩角（Tait–Bryan angles）：x-y-z, y-z-x, z-x-y, x-z-y, z-y-x, y-x-z

我们平时所说的roll, pitch, yaw 其实是泰特-布莱恩角，我简称之为TB角

可以看出两者的区别是：经典欧拉角的第一个旋转角度和第三个旋转角度都是围绕同一个轴的，而Tait-Bryan角使用三个轴上的旋转角度去表示

  • 内旋和外旋

同样的一个旋转，按旋转的坐标系又可分为内旋和外旋。

内旋是基于自身坐标系的旋转，旋转轴是动态的。内旋的旋转矩阵是按顺序右乘，

外旋是基于外部坐标系的旋转，旋转轴始终不变，也就是RPY。外旋的旋转矩阵是按顺序左乘。

所以欧拉角要知道旋转顺序和是否定轴旋转，而旋转矩阵和四元数则是一个姿态就对应的一个旋转矩阵或四元数。除了万向锁问题，这也是SLAM不常用欧拉角的另一个原因。

在使用欧拉角的场合，大多数情况下都是采取外旋 XYZ


转换

欧拉角和旋转矩阵

《SLAM十四讲》没有讲到这部分。坐标系A旋转到坐标系B，先绕Z轴旋转了yaw，这里遵循右手法则，大拇指朝坐标系方向，四指代表正向。或者说正向旋转是以沿X轴方向看，顺时针旋转为正向，否则为负向。那么相应的旋转矩阵为
绕坐标轴旋转的轴坐标是不会变化的，所以对应位置是1
之后绕旋转后坐标系的Y轴旋转了pitch，之后绕旋转后坐标系X轴旋转了roll，最终的旋转矩阵如下，即依次左乘相应的矩阵

典型举例

如图，大坐标系是base_link，小的是 camera

我们希望的坐标系关系是这样的

变化的过程是camera坐标系做内旋方式，也就是绕自身轴按照Z-Y-X的顺序旋转，即先绕自身轴Z，再绕自身轴Y，最后绕自身轴X，可得旋转矩阵(内旋是右乘)

判断欧拉角的正负: 使用右手系，旋转轴正方向面对观察者时，逆时针方向的旋转是正、顺时针方向的旋转是负。这里先绕Z轴转 -90°，再绕X轴转-90°，camera就能变成希望的样子。

最终的旋转矩阵

打开网站rotationconverter，在左上角的旋转矩阵输入计算的结果，在右下角出现XYZ对应的结果，而我们需要的是ZYX，即[ x: -90, y: 0, z: -90 ]，这里并不是简单的把XYZ的结果倒序就行了。

我们要的欧拉角rpy就是 (-1.57, 0, -1.57)

旋转向量

旋转矩阵有几个缺点：SO(3)的旋转矩阵有9个量，但一次旋转只有3个自由度。因此，这种表达式冗余。而且对于旋转矩阵自身也有约束，它必须是正交矩阵，且行列式为1，这些约束会使求解变得困难。扩展到变换矩阵，就是用16个量表达了6个自由度的变换。

上面说的欧拉角是绕三个正交轴的依次旋转，其实任意旋转都可以用一个旋转轴和一个旋转角来表示。这只需要一个旋转向量即可，也就是说一个三维向量表示了旋转，再加上一个平移向量，这样就是6个自由度，没有冗余了。

四元数

Quaternion用一个冗余的变量解决了欧拉角的Singularity问题，在运算插值时也比较方便，因此四元数是程序中表示旋转最常用的一种表示方法

四元数——>旋转矩阵——>欧拉角 这个过程转出来的欧拉角，不可能是想要的。因为同一个四元数，可以用2个欧拉角来表示，而这个方法得到的结果有可能是用转角大于2π的方式表达的．

最好不要直接从四元数转欧拉角后，处理向量的旋转．

四元数加减法： 四元数的加法只需要将分量相加就可以了

四元数的共轭是让四元数的向量部分取负，记做 (w, -x, -y, -z)。 四元数和它的共轭代表相反的角位移，因为相当于旋转轴反向。

四元数的逆表示一个反向的旋转，定义为四元数的共轭除以它的模的平方，四元数和逆的乘积为实数 1。 如果是单位四元数，那么逆就是共轭

四元数的插值不能用简单的线性插值，而是用slerp。因为当时间t匀速变化时，代表姿态矢量的角速度变化并不均匀

Eigen::Quaterniond::Identity().slerp(t, q_last_curr)能够实现四元数的球面插值。
t ∈ [0, 1]为插值点，q_last_curr为两帧之间的旋转四元数，即针对两帧之间的旋转而线性插入一个四元数。

cartographer中重新实现的slerp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
template <typename T>
std::array<T, 4> SlerpQuaternions(const T* const start, 
                                  const T* const end,
                                  double factor)
{
  // Angle 'theta' is the half-angle "between" quaternions. It can be computed
  // as the arccosine of their dot product.
  const T cos_theta = start[0] * end[0] + start[1] * end[1] +
                      start[2] * end[2] + start[3] * end[3];
  // Avoid using ::abs which would cast to integer.
  const T abs_cos_theta = ceres::abs(cos_theta);
  // If numerical error brings 'cos_theta' outside [-1 + epsilon, 1 - epsilon]
  // interval, then the quaternions are likely to be collinear.
  T prev_scale(1. - factor);
  T next_scale(factor);
  if (abs_cos_theta < T(1. - 1e-5)) {
    const T theta = acos(abs_cos_theta);
    const T sin_theta = sin(theta);
    prev_scale = sin((1. - factor) * theta) / sin_theta;
    next_scale = sin(factor * theta) / sin_theta;
  }
  if (cos_theta < T(0.)) {
    next_scale = -next_scale;
  }
  return {{prev_scale * start[0] + next_scale * end[0],
           prev_scale * start[1] + next_scale * end[1],
           prev_scale * start[2] + next_scale * end[2],
           prev_scale * start[3] + next_scale * end[3]}};
}

参考：
四元数和欧拉角互相转换
欧拉角与旋转矩阵

搭建Hexo博客|常用工具

Disqus评论

按这个教程操作即可

快捷上传图片

以前一直用flicker，每次都到网站上传，然后复制图片的网址，操作实在太麻烦了，而且flicker有上传图片限制。今天终于看到一种简便的方法，使用一个Hexo Editor的工具，截图之后复制图片文本，比如![](/20190616210334907/20190616091008239.png)，然后右键选择上传SM.MS，这时图片会上传到图床SM.MS，这个图床应当没有上传限制，并且把图片的网址直接复制到剪贴板：![](https://i.loli.net/2019/06/16/5d064094f300180845.png)

问题

hexo g 报错

1
2
3
4
5
6
7
8
9
INFO  Start processing
FATAL Something's wrong. Maybe you can find the solution here: http://hexo.io/docs/troubleshooting.html
TypeError: ejs:13
    11|         <title><%-: post.title %></title>
    12|         <pubTime><%= post.date.toDate().toISOString() %></pubTime>
 >> 13|         <%if(post.tags){ post.tags.toArray().forEach(function(tag){ %>
    14|         <tag><%= tag.name %></tag>
    15|          <% })}/*%>
    16|          <content><%-: post.content%></content>

将hexo-generator-baidu-sitemap文件删除掉即可

另一个可能的原因：把一个未写完的.md文件放到了_posts文件夹同名下，也就是放到了source文件夹下

hexo d报错


结果是git配置和SSH Key的问题

还在hexo博客的根目录，执行ssh-keygen，根据提示一直按回车即可，一般生成的位置在C:\Users\username\.ssh，找到id_rsa.pub后打开，到github网站的Settings中新建一个SSH key，将id_rsa.pub中的内容复制到Key中

用git config --global配置git的用户名和邮箱

通过命令ssh-add解决每次操作都需要输入key的密码的问题

使用ssh -v git@github.com测试连接，如果看到验证通过就是成功了



algolia搜索

整个配置过程参见

如果搜索成功，在algolia网站的indices项目可以测试搜索结果

问题1

开始一直安装algolia失败，发现是把package.json设置为只读了

问题2

安装配置成功后，打开博客发现有了搜索按钮但没出现搜索条，在网页上按F12打开网页源码发现有报错，所以是浏览器问题而不是algolia的问题．


解决方法：还用npm安装hexo插件hexo-all-minifier，重新执行hexo clean和hexo algolia，再hexo g hexo d，打开博客应该成功了．

问题3

搜索时会发现不在post目录的文章也能搜索到，但是打开是404

参考：
Youtube上的视频教程

Latex 常用语法|常用工具

常见符号

\hat x        
\bar x        
\div        
\times        
\sin\theta        
a\in A        
\frac{2}{4}        
点乘：a \cdot b
叉乘：a \times b
除以：a \div b

中括号: \left[ \frac{a}{b} \right]
大括号: \left{ \frac{a}{b} \right}

希腊字母

\xi        
\pi        
\alpha        
\beta        
\lambda        
\gamma \delta \epsilon \zeta \eta \theta        
\Sigma\sigma\varsigma        

集合

\mathbb Z         整数集

特殊符号

\bigoplus        
\oplus        

变体

斜体     \mathit{0123456789}        

粗体     \boldsymbol{0123456789}        

花体，用于集合     \mathbb{ABCD}        

向量

\vec{}可以表示向量，使用更为普遍的是：

\overrightarrow{AB}        

\overleftarrow{AB}        

默认情况下，在 LaTeX 中输入向量\vec x，向量 x 上头会出现一个箭头而非加粗:

要使用向量的粗体格式，改用 \boldsymbol 即可。

范数： \Vert x \Vert

换行命令

\\：换行，在博客环境下不好用
\\[offset]：换行，并且与下一行的行间距为原来行间距+offset
\newline：与\相同，能在博客环境下换行
\linebreak：强制换行，与\newline的区别为\linebreak的当前行分散对齐

\\会自动让下一行缩进，也就是形成一个段落，有时不是我们需要的
回车出一个空行，不会造成缩进

矩阵

\left[ \begin{matrix} R & t \\ 0 & 1 \\ \end{matrix} \right]

常用公式

\mathop{min}\limits_{x}{\frac{1}{2}\left|f(x)\right|_2^2}\tag1

\varepsilon^* = arg\ \mathop{max} \limits{\varepsilon \in \mathcal{W}} \sum\limits{k=1}^{K}M\

数学模式

用两个美元括号括起来是一般的数学模式，例如 $y=x+1$ ，结果是斜体的，这是行内模式．
还有行间模式：

结果是换行显示公式

行内公式也可以使用 (…) 或者 \begin{math} ... \end{math} 来插入。
行间公式也可以使用 [ … ] 或者 \begin{displaymath} ... \end{displaymath} 来插入。

Eigen(一) 安装配置 和 基础|SLAM工具

Eigen是一个基于C++模板的线性代数库，安装后只需要包含头文件即可，它没有库文件，所以不需要链接，一般是INCLUDE_DIRECTORIES(/usr/include/eigen3)

安装：sudo apt-get install libeigen3-dev，这是最新版本

查看Eigen的版本：不能用命令查看，版本在Macros.h，在/usr/local/include/eigen3/Eigen/src/Core/util，可以执行命令： grep 'define EIGEN_....._VERSION\>' $(locate Macros.h | grep Core/util)，结果是三个版本部分的宏定义。目前我所用为3.2.92

卸载Eigen：删除所有Eigen的文件即可

1
2
3
sudo rm -rf /usr/include/eigen3 /usr/lib/cmake/eigen3 /usr/share/doc/libeigen3-dev /usr/share/pkgconfig/eigen3.pc /var/lib/dpkg/info/libeigen3-dev.list /var/lib/dpkg/info/libeigen3-dev.md5sums
sudo updatedb
locate eigen

如果locate之后没有结果，那就是卸载成功了

要安装其他版本，就需要下载对应得deb安装，比如libeigen3-dev_3.2.0-8_all.deb，我使用gdebi安装时失败，报警 A later version is already installed ，最终发现还是要用dpkg安装，这一点以前没有发现，其他软件包应该也会有这样问题

矩阵Eigen::Matrix基本使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <Eigen/Core>　　// 核心文件
#include <Eigen/Dense>　// 包含了常用函数，稠密矩阵的运算
#include <Eigen/Eigen>  　// 稀疏部分

// 矩阵基本使用
Eigen::Matrix<float, 2, 3> m23;
m23.setZero(2,3);       // 矩阵置为0，参数分别为行数和列数
cout << "After m23 initilized!" << endl;
cout<<m23<<endl;    // 可以将矩阵放入标准输出流，输出结果就是矩阵形式，源码应当做了空格和换行处理
m23<<1,2,3,4,5,6;   　// 矩阵赋值的常用方式
cout << "After m23 set value!" << endl;
m23(1,2) = 54;  　　// 单独给某元素赋值
// 输出元素的值
 　cout<<m23(1,2)<<endl;


Eigen::Matrix<double,2,2> information;
information.fill(0.0);   // 矩阵元素全赋值为 0.0

// 常用的类型Matrix3Xd和Matrix3Xf其实是动态矩阵，定义如下
// typedef Matrix< double, 3, Dynamic >    Eigen::Matrix3Xd
// typedef Matrix< float, 3, Dynamic >     Eigen::Matrix3Xf
// Eigen::Matrix3d 三阶方阵
 
Eigen::Matrix<float, 2, 3> m;
m.setRandom(2,3);            // 矩阵用随机值初始化，但每次随机值似乎都是一样的
m = m23;                //  将另一矩阵的值赋给m
m<<3,4,7,12,-2,10;
cout<<m23+m<<endl;      // 矩阵加法
cout<<m23 * m.transpose()<<endl;    // 矩阵乘法

Eigen::Matrix3d m33
m33<<1,6,3,4,12,5,7,8,9;
cout<<m33<<endl;
cout<<m33.rows()<<endl;                     // 行数
cout<<m33.cols()<<endl;                      // 列数
cout << "Column major input:" << endl << m33 << "\n";
// 获取第一列的元素
cout << "The first column is:" << endl << m33.col(0) << "\n";
cout << "The last column is: " << endl << m33.rightCols(1) << "\n";
cout << "The first row is: " << endl << m33.topRows<1>() << endl;
cout << "The last row is: " << endl << m33.bottomRows<1>() << endl;
// rowwise和colwise两个函数很奇怪，不要使用
cout<<m33.transpose()<<endl;        // 转置矩阵
cout<<m33.sum()<<endl;                  // 所有元素的和
cout<<m33.trace()<<endl;                // 矩阵的迹
cout<<10*m33<<endl;                         //  矩阵数乘
cout<<m33.isUnitary()<<endl;      // 判断该矩阵是否是酉矩阵(矩阵各列是否为标准正交基)
cout<<m33.conjugate()<<endl;     //  共轭矩阵
cout<<m33.adjoint()<<endl;           //  伴随矩阵
cout<<m33.inverse()<<endl;          //  逆矩阵，若不存在会报错
cout<<m33.determinant()<<endl;   // 行列式结果，若不存在会报错

// 矩阵乘法, m23模板类型是float，需要转换，注意cast不能自动提示
Eigen::Matrix<double, 2, 1> m21 = m23.cast<double>() * v3d;

由于元素级运算在矩阵中很常见，所以Eigen对于Matrix其实内置了一些函数，均以cwise开头。mat.cwiseAbs()元素取绝对值、mat.cwiseSqrt()逐元素开根号、mat.cwiseMin()将两个矩阵中相应位置的最小值组成一个新矩阵

Eigen提供了一些基础的算法，如sum()，求所有元素和；prod()，求所有元素之积；mean()，求元素平均值；minCoeff()，最小元素；maxCoeff()，最大元素；trace()，求迹

Eigen::Isometry3d

Eigen::Isometry3d相当于一个四维矩阵

1
2
3
4
5
6
7
8
9
Eigen::AngleAxisd  v(M_PI / 3, Eigen::Vector3d(1,0,0).normalized() );
Eigen::Quaterniond q(1,0,0,0);
Eigen::Vector3d translate(1,2,3);
// 初始化为单位矩阵
Eigen::Isometry3d T = Eigen::Isometry3d::Identity();
T.translate(translate);
// T.rotate(q.matrix() )  或者 T.rotate(v)
T.rotate(q);
cout << endl << T.matrix() << endl;

rotate函数比较强大，可接受的参数有四元数、旋转矩阵、旋转向量

必须要调用 Isometry3d::Identity()对它进行初始化，后面的translate()和rotate()函数才有用。

稀疏矩阵

使用方式和普通矩阵不同

1
2
3
4
Eigen::SparseMatrix<double> hessian(2, 2);
// 注意稀疏矩阵的初始化方式,无法使用<<初始化
hessian.insert(0, 0) = 2.0; 
hessian.insert(1, 1) = 2.0;

从子矩阵和向量拼接成新矩阵

比如现在有一个3X3的矩阵，一个行向量和一个列向量，二者的最后一个元素相同，要拼接成4X4的矩阵

mat = mat1.block(i, j, p, q); // 从矩阵 mat1 的 i 行 j 列开始获取一个 p 行 q 列的子矩阵
mat = mat1.block<p, q>(i, j); // 从矩阵 mat1 的 i 行 j 列开始获取一个 p 行 q 列的子矩阵（动态矩阵）

1
2
3
4
5
6
7
8
9
Eigen::Matrix4d m;
Eigen::Matrix3d rotation;
// 给 rotation赋值
m.block(0,0,3,3) = rotation;

Eigen::Vector4d Vcol, Vrow;
// 给 Vcol和Vrow 赋值
m.col(3) = Vcol;
m.row(3) = Vrow.transpose();

向量Eigen::Vector

1
2
3
4
5
6
7
8
9
10
11
12
// 常用这种方式，Xd 代表double型的任意行数向量，但后面的参数必须指定行数
Eigen::VectorXd v(3);  
v<< 1,2,5;          // 必须不多不少传入所有的元素值，否则报错
v(2) = 9;          // 给第三个元素赋值


Eigen::VectorXd vv(12); 
vv<< 1,2,3,4,5,6,7,8,9,10,11,12;
// 前三行
cout<< vv.block(0,0, 3,1).transpose() <<endl<<endl;
cout<< vv.block(3,0, 3,1) <<endl<<endl;
cout<< vv.block(6,0, 3,1) <<endl<<endl;

指定了3行，必须传入3个值，否则运行报错。

我们可以用Vector3f::UnitX(), Vector3f::UnitY 和 Vector3f::UnitZ()这三个函数表示三个方向的列向量，也就是输出结果为：

1
2
3
4
5
X   Y   Z

1   0   0
0   1   0
0   0   1

其实向量只是一个特殊的矩阵，但是Eigen也为它单独提供了一些简化的块操作，如下三种形式：

head tail segment

  • 获取向量的前n个元素：vector.head(n);

  • 获取向量尾部的n个元素：vector.tail(n);

  • 获取从向量的第i个元素开始的n个元素：vector.segment(i,n);

1
2
3
4
5
6
Eigen::Vector4d v(4); 
v<< 1,2,3,4;

cout << "head: "<<v.head(1) <<endl; // 1
cout << v.segment(1,2) <<endl;  // 2 3
cout << "tail: "<<v.tail(1) <<endl;  // 4

Vector 转 Matrix

1
2
3
4
Eigen::Vector3d v;
v << 1,2,3;
// 这个转换十分罕见
Eigen::Matrix<double, 3, 1> m = v.template cast<double>();

从Eigen::Vector构建对角矩阵，其中Vector的元素占据矩阵的主对角线

1
2
Eigen::Vector3d v(1,2,3);
Eigen::Matrix3d m = v.asDiagonal();

从多个Eigen::Vector拼接成Eigen::Matrix

1
2
3
4
5
6
7
8
Eigen::Vector3d v(3);
v<< 2.1, 4.9, 0.4;
std::vector<Eigen::Vector3d> vv;
for(int i=0;i<4;i++)
    vv.push_back( v );
// 拼接成3X4的矩阵
Eigen::Map<Eigen::Matrix3Xd> matrix(&vv[0].x(), 3, 4);  //首元素地址，行，列
cout << matrix <<endl;

Map类用于通过C++中普通的连续指针或者数组 （指针地址连续）来构造Eigen里的Matrix类，这就好比Eigen里的Matrix类的数据和raw C++array 共享了一片地址，也就是引用。

有个庞大的Matrix类，在一个大循环中要不断读取Matrix中的一段连续数据，如果每次都用block operation 去引用数据会太繁琐。于是就事先将这些数据构造成若干Map，那么以后循环中直接操作Map就行了。

Eigen::Map

Map类用于通过C++中普通的连续指针或者数组来构造Eigen里的Matrix类，这就好比Eigen里的Matrix类的数据和raw C++array 共享了一片地址，也就是引用。 比如有个API只接受普通的C++数组，但又要对普通数组进行线性代数操作，那么用它构造为Map类。 实际上Map类并没有自己申请一片空内存，只是一个引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using DynamicArray = Eigen::Array<int, Eigen::Dynamic, Eigen::Dynamic>;

std::vector<int> cells{1,2,3,4,5,6,7,8,9};
for(auto& v: cells)
    cout << v << "  ";
cout << endl << endl;
// 维度不要超过 3x3，否则出现invalid数据
Eigen::Map<const DynamicArray> full_correspondence_costs(cells.data(), 3, 3);
cout << full_correspondence_costs <<endl;


int data[] = {1,2,3,4,5,6,7,8,9};
Eigen::Map<Eigen::RowVectorXi> m(data, 4);
cout << "The mapped vector v is: " << m << "\n";

运行结果：
1
2
3
4
1 4 7
2 5 8
3 6 9
The mapped vector v is: 1 2 3 4

参考：
Eigen矩阵库使用说明