这个文件主要包括fcos的网络结构，包含三个loss: loss_cls, loss_reg, loss_centerness。

其中一个关键函数是compute_locations：

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

def compute_locations(self, features):
    locations = []
    for level, feature in enumerate(features):
        h, w = feature.size()[-2:]
        locations_per_level = self.compute_locations_per_level(
            h, w, self.fpn_strides[level],
            feature.device
        )
        locations.append(locations_per_level)
    return locations

def compute_locations_per_level(self, h, w, stride, device):
    shifts_x = torch.arange(
        0, w * stride, step=stride,
        dtype=torch.float32, device=device
    )
    shifts_y = torch.arange(
        0, h * stride, step=stride,
        dtype=torch.float32, device=device
    )
    shift_y, shift_x = torch.meshgrid(shifts_y, shifts_x)
    shift_x = shift_x.reshape(-1)
    shift_y = shift_y.reshape(-1)
    locations = torch.stack((shift_x, shift_y), dim=1) + stride // 2
    return locations

对于fpn的5个特征图：P3，P4，P5，P6，P7，计算特征图上的点映射到原图的位置，即生成一个二维网格（meshgrid）。

上面代码的24行加上stride // 2是为了解决一个向下取整造成的问题，使原图上的对应点尽可能接近location(x,y)的感受野中心。

最后得到的locations是一个list，包含5个level特征图的所有点映射到原图的坐标。

fcos_core/modeling/rpn/fcos/loss.py

上述locations作为了prepare_targets函数的第一个参数。

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

def prepare_targets(self, points, targets):
    object_sizes_of_interest = [
        [-1, 64],
        [64, 128],
        [128, 256],
        [256, 512],
        [512, INF],
    ]
    expanded_object_sizes_of_interest = []
    for l, points_per_level in enumerate(points):
        # a.new_tensor has the same type with a
        object_sizes_of_interest_per_level = \
            points_per_level.new_tensor(object_sizes_of_interest[l])
        expanded_object_sizes_of_interest.append(
            object_sizes_of_interest_per_level[None].expand(len(points_per_level), -1)
        )

    expanded_object_sizes_of_interest = torch.cat(expanded_object_sizes_of_interest, dim=0)
    num_points_per_level = [len(points_per_level) for points_per_level in points]
    self.num_points_per_level = num_points_per_level
    points_all_level = torch.cat(points, dim=0)
    # shape: (P, N), (P, N, 4), P is the image nums
    labels, reg_targets = self.compute_targets_for_locations(
        points_all_level, targets, expanded_object_sizes_of_interest
    )

    # labels[i] is a tuple
    for i in range(len(labels)):
        labels[i] = torch.split(labels[i], num_points_per_level, dim=0)
        reg_targets[i] = torch.split(reg_targets[i], num_points_per_level, dim=0)

    labels_level_first = []
    reg_targets_level_first = []
    # labels_level_first[level] has P*N_level elements
    # reg_targets_level_first[level] has shape (P*N_level, 4)
    for level in range(len(points)):
        labels_level_first.append(
            torch.cat([labels_per_im[level] for labels_per_im in labels], dim=0)
        )

        reg_targets_per_level = torch.cat([
            reg_targets_per_im[level]
            for reg_targets_per_im in reg_targets
        ], dim=0)

        if self.norm_reg_targets:
            reg_targets_per_level = reg_targets_per_level / self.fpn_strides[level]
        reg_targets_level_first.append(reg_targets_per_level)

    return labels_level_first, reg_targets_level_first

首先构造了一个expanded_object_sizes_of_interest变量，对于每一个采样点，都需要有一个对应的sizes_of_interest。expanded_object_sizes_of_interest按照每个level创建了该level所有采样点的sizes_of_interest，然后用torch.cat合并起来，形成了(N, 2)形状的数据，N为所有采样点的个数。

num_points_per_level是每个level的点个数，这个用于后续的操作。

points_all_level包含了所有采样点，跟expanded_object_sizes_of_interest类似，也用torch.cat合并，形成了(N, 2)的形状。

compute_targets_for_locations函数使用points_all_level, targets, expanded_object_sizes_of_interest计算分类和回归的标注即labels和reg_targets，形状为(P, N)和(P, N, 4)，P为图像数量。

compute_targets_for_locations函数得到的labels和reg_targets是把所有level的数据拼接在一起的。现在要根据每个level的点个数即num_points_per_level把他们拆开，按照level优先做成一个list。最后的结果是labels_level_first[level]，拥有P*N_level个元素。reg_targets_level_first[level]形状为(P*N_level, 4)，N_level为该level采样点的个数。

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

def compute_targets_for_locations(self, locations, targets, object_sizes_of_interest):
    labels = []
    reg_targets = []
    xs, ys = locations[:, 0], locations[:, 1]

    for im_i in range(len(targets)):
        targets_per_im = targets[im_i]
        assert targets_per_im.mode == "xyxy"
        bboxes = targets_per_im.bbox
        labels_per_im = targets_per_im.get_field("labels")
        area = targets_per_im.area()

        l = xs[:, None] - bboxes[:, 0][None]
        t = ys[:, None] - bboxes[:, 1][None]
        r = bboxes[:, 2][None] - xs[:, None]
        b = bboxes[:, 3][None] - ys[:, None]
        # shape: (N, M, 4)
        reg_targets_per_im = torch.stack([l, t, r, b], dim=2)

        if self.center_sampling_radius > 0:
            is_in_boxes = self.get_sample_region(
                bboxes,
                self.fpn_strides,
                self.num_points_per_level,
                xs, ys,
                radius=self.center_sampling_radius
            )
        else:
            # no center sampling, it will use all the locations within a ground-truth box
            is_in_boxes = reg_targets_per_im.min(dim=2)[0] > 0

        max_reg_targets_per_im = reg_targets_per_im.max(dim=2)[0]
        # limit the regression range for each location
        is_cared_in_the_level = \
            (max_reg_targets_per_im >= object_sizes_of_interest[:, [0]]) & \
            (max_reg_targets_per_im <= object_sizes_of_interest[:, [1]])

        locations_to_gt_area = area[None].repeat(len(locations), 1)
        locations_to_gt_area[is_in_boxes == 0] = INF
        locations_to_gt_area[is_cared_in_the_level == 0] = INF

        # if there are still more than one objects for a location,
        # we choose the one with minimal area

        # shape (N)
        locations_to_min_area, locations_to_gt_inds = locations_to_gt_area.min(dim=1)

        reg_targets_per_im = reg_targets_per_im[range(len(locations)), locations_to_gt_inds]
        labels_per_im = labels_per_im[locations_to_gt_inds]
        labels_per_im[locations_to_min_area == INF] = 0

        labels.append(labels_per_im)
        reg_targets.append(reg_targets_per_im)

    return labels, reg_targets

由于每张图像可能含有不同数量的bbox，所以先读取targets的labels和bbox，创建labels_per_im变量和reg_targets_per_im变量（形状为(N, M, 4)，N为所有采样点的个数，M为bbox数量）。

根据论文3.2节，不同尺度大小的bbox将被分配到不同的fpn level去计算，不在level对应范围的bbox将被忽略。这样操作之后若某一个采样点仍然对应到多个bbox，则取最小面积的bbox。fcos中的实现是把level对应范围之外的bbox面积设成无穷大，用locations_to_gt_area这个变量实现位置到gt中面积的映射，代码48行使reg_targets_per_im取到面积最小的bbox。同理每个采样点也有一个对应的类别，对于不在gt bbox的点类别设成背景。最终的labels_per_im形状为(N)，reg_targets_per_im形状为(N, 4)。

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

def __call__(self, locations, box_cls, box_regression, centerness, targets):
    """
    Arguments:
        locations (list[Tensor])
        box_cls (list[Tensor])
        box_regression (list[Tensor])
        centerness (list[Tensor])
        targets (list[BoxList])

    Returns:
        cls_loss (Tensor)
        reg_loss (Tensor)
        centerness_loss (Tensor)
    """
    N = box_cls[0].size(0)
    num_classes = box_cls[0].size(1)
    labels, reg_targets = self.prepare_targets(locations, targets)

    box_cls_flatten = []
    box_regression_flatten = []
    centerness_flatten = []
    labels_flatten = []
    reg_targets_flatten = []
    for l in range(len(labels)):
        box_cls_flatten.append(box_cls[l].permute(0, 2, 3, 1).reshape(-1, num_classes))
        box_regression_flatten.append(box_regression[l].permute(0, 2, 3, 1).reshape(-1, 4))
        labels_flatten.append(labels[l].reshape(-1))
        reg_targets_flatten.append(reg_targets[l].reshape(-1, 4))
        centerness_flatten.append(centerness[l].reshape(-1))

    box_cls_flatten = torch.cat(box_cls_flatten, dim=0)
    box_regression_flatten = torch.cat(box_regression_flatten, dim=0)
    centerness_flatten = torch.cat(centerness_flatten, dim=0)
    labels_flatten = torch.cat(labels_flatten, dim=0)
    reg_targets_flatten = torch.cat(reg_targets_flatten, dim=0)

    pos_inds = torch.nonzero(labels_flatten > 0).squeeze(1)

    box_regression_flatten = box_regression_flatten[pos_inds]
    reg_targets_flatten = reg_targets_flatten[pos_inds]
    centerness_flatten = centerness_flatten[pos_inds]

    num_gpus = get_num_gpus()
    # sync num_pos from all gpus
    total_num_pos = reduce_sum(pos_inds.new_tensor([pos_inds.numel()])).item()
    num_pos_avg_per_gpu = max(total_num_pos / float(num_gpus), 1.0)

    cls_loss = self.cls_loss_func(
        box_cls_flatten,
        labels_flatten.int()
    ) / num_pos_avg_per_gpu

    if pos_inds.numel() > 0:
        centerness_targets = self.compute_centerness_targets(reg_targets_flatten)

        # average sum_centerness_targets from all gpus,
        # which is used to normalize centerness-weighed reg loss
        sum_centerness_targets_avg_per_gpu = \
            reduce_sum(centerness_targets.sum()).item() / float(num_gpus)

        reg_loss = self.box_reg_loss_func(
            box_regression_flatten,
            reg_targets_flatten,
            centerness_targets
        ) / sum_centerness_targets_avg_per_gpu
        centerness_loss = self.centerness_loss_func(
            centerness_flatten,
            centerness_targets
        ) / num_pos_avg_per_gpu
    else:
        reg_loss = box_regression_flatten.sum()
        reduce_sum(centerness_flatten.new_tensor([0.0]))
        centerness_loss = centerness_flatten.sum()

    return cls_loss, reg_loss, centerness_loss

fcos_core/modeling/rpn/fcos/inference.py

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
56
57
58
59
60
61
62
63
64
65
66

def forward_for_single_feature_map(
            self, locations, box_cls,
            box_regression, centerness,
            image_sizes):
        """
        Arguments:
            anchors: list[BoxList]
            box_cls: tensor of size N, A * C, H, W
            box_regression: tensor of size N, A * 4, H, W
        """
        N, C, H, W = box_cls.shape

        # put in the same format as locations
        box_cls = box_cls.view(N, C, H, W).permute(0, 2, 3, 1)
        box_cls = box_cls.reshape(N, -1, C).sigmoid()
        box_regression = box_regression.view(N, 4, H, W).permute(0, 2, 3, 1)
        box_regression = box_regression.reshape(N, -1, 4)
        centerness = centerness.view(N, 1, H, W).permute(0, 2, 3, 1)
        centerness = centerness.reshape(N, -1).sigmoid()

        candidate_inds = box_cls > self.pre_nms_thresh
        pre_nms_top_n = candidate_inds.view(N, -1).sum(1)
        pre_nms_top_n = pre_nms_top_n.clamp(max=self.pre_nms_top_n)

        # multiply the classification scores with centerness scores
        box_cls = box_cls * centerness[:, :, None]

        results = []
        for i in range(N):
            per_box_cls = box_cls[i]
            per_candidate_inds = candidate_inds[i]
            per_box_cls = per_box_cls[per_candidate_inds]

            per_candidate_nonzeros = per_candidate_inds.nonzero()
            per_box_loc = per_candidate_nonzeros[:, 0]
            per_class = per_candidate_nonzeros[:, 1] + 1

            per_box_regression = box_regression[i]
            per_box_regression = per_box_regression[per_box_loc]
            per_locations = locations[per_box_loc]

            per_pre_nms_top_n = pre_nms_top_n[i]

            if per_candidate_inds.sum().item() > per_pre_nms_top_n.item():
                per_box_cls, top_k_indices = \
                    per_box_cls.topk(per_pre_nms_top_n, sorted=False)
                per_class = per_class[top_k_indices]
                per_box_regression = per_box_regression[top_k_indices]
                per_locations = per_locations[top_k_indices]

            detections = torch.stack([
                per_locations[:, 0] - per_box_regression[:, 0],
                per_locations[:, 1] - per_box_regression[:, 1],
                per_locations[:, 0] + per_box_regression[:, 2],
                per_locations[:, 1] + per_box_regression[:, 3],
            ], dim=1)

            h, w = image_sizes[i]
            boxlist = BoxList(detections, (int(w), int(h)), mode="xyxy")
            boxlist.add_field("labels", per_class)
            boxlist.add_field("scores", torch.sqrt(per_box_cls))
            boxlist = boxlist.clip_to_image(remove_empty=False)
            boxlist = remove_small_boxes(boxlist, self.min_size)
            results.append(boxlist)

        return results

这个文件主要完成推理阶段的操作，forward_for_single_feature_map对每个fpn level的结果做后处理。

网络输出的box_cls, box_regression, centerness和locations作为输入，由pre_nms_thresh取阈值，得到大于阈值的点的索引candidate_inds。

对pre_nms_top_n做clamp操作使其最大值为self.pre_nms_top_n，也就是最多保留这么多个点。如果candidate_inds求和（即保留的点数量）大于pre_nms_top_n，则保留box_cls, class, box_regression, locations的top_k个结果。最后把结果添加到boxlist的结构中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def select_over_all_levels(self, boxlists):
    num_images = len(boxlists)
    results = []
    for i in range(num_images):
        # multiclass nms
        result = boxlist_ml_nms(boxlists[i], self.nms_thresh)
        number_of_detections = len(result)

        # Limit to max_per_image detections **over all classes**
        if number_of_detections > self.fpn_post_nms_top_n > 0:
            cls_scores = result.get_field("scores")
            image_thresh, _ = torch.kthvalue(
                cls_scores.cpu(),
                number_of_detections - self.fpn_post_nms_top_n + 1
            )
            keep = cls_scores >= image_thresh.item()
            keep = torch.nonzero(keep).squeeze(1)
            result = result[keep]
        results.append(result)
    return results

select_over_all_levels对刚才的所有level的结果做nms（C++实现），然后取得分最高的fpn_post_nms_top_n个检测结果，使用torch.kthvalue得到cls_scores的阈值。

参考资料

[Paper] [Code] Tian, Zhi, et al. “FCOS: Fully Convolutional One-Stage Object Detection.” arXiv preprint arXiv:1904.01355 (2019).

DeeplabV3 code do not contain SBD annotations for some reasons that we can understand. So I wrote a simple script to solve this.

To use 10,582 trainaug images on DeeplabV3 code, you just need to do the following steps:

1. Create a script named convert_voc2012_aug.sh.

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

# Exit immediately if a command exits with a non-zero status.
set -e

CURRENT_DIR=$(pwd)
WORK_DIR="./pascal_voc_seg"
mkdir -p ${WORK_DIR}

cd ${WORK_DIR}
tar -xf "../VOCtrainval_11-May-2012.tar"
cp "../trainaug.txt" "./VOCdevkit/VOC2012/ImageSets/Segmentation"
unzip "../SegmentationClassAug.zip" -d "./VOCdevkit/VOC2012"
rm -r "./VOCdevkit/VOC2012/__MACOSX"

cd ${CURRENT_DIR}

# Root path for PASCAL VOC 2012 dataset.
PASCAL_ROOT="${WORK_DIR}/VOCdevkit/VOC2012"

# Remove the colormap in the ground truth annotations.
SEG_FOLDER="${PASCAL_ROOT}/SegmentationClassAug"
SEMANTIC_SEG_FOLDER="${PASCAL_ROOT}/SegmentationClassAugRaw"

echo "Removing the color map in ground truth annotations..."
python ./remove_gt_colormap.py \
  --original_gt_folder="${SEG_FOLDER}" \
  --output_dir="${SEMANTIC_SEG_FOLDER}"

# Build TFRecords of the dataset.
# First, create output directory for storing TFRecords.
OUTPUT_DIR="${WORK_DIR}/tfrecord"
mkdir -p "${OUTPUT_DIR}"

IMAGE_FOLDER="${PASCAL_ROOT}/JPEGImages"
LIST_FOLDER="${PASCAL_ROOT}/ImageSets/Segmentation"

echo "Converting PASCAL VOC 2012 dataset..."
python ./build_voc2012_data.py \
  --image_folder="${IMAGE_FOLDER}" \
  --semantic_segmentation_folder="${SEMANTIC_SEG_FOLDER}" \
  --list_folder="${LIST_FOLDER}" \
  --image_format="jpg" \
  --output_dir="${OUTPUT_DIR}"

2. Create a txt file named trainaug.txt with this content.

3. Download Pascal VOC dataset and SegmentationClassAug annotations.

4. Put all of them (‘convert_voc2012_aug.sh’, ‘trainaug.txt’, ‘VOCtrainval_11-May-2012.tar’, ‘SegmentationClassAug.zip’) to the research/deeplab/datasets folder.

5. Execute convert_voc2012_aug.sh (give it execute permission) in research/deeplab/datasets.

6. Change the code in research/deeplab/datasets/segmentation_dataset.py from:

1
2
3
4
5
6
7
8
9

_PASCAL_VOC_SEG_INFORMATION = DatasetDescriptor(
    splits_to_sizes={
        'train': 1464,
        'trainval': 2913,
        'val': 1449,
    },
    num_classes=21,
    ignore_label=255,
)

to:

1
2
3
4
5
6
7
8
9
10

_PASCAL_VOC_SEG_INFORMATION = DatasetDescriptor(
    splits_to_sizes={
        'train': 1464,
        'trainaug': 10582,
        'trainval': 2913,
        'val': 1449,
    },
    num_classes=21,
    ignore_label=255,
)

7. Don’t forget to change the train_split parameter in research/deeplab/train.py to trainaug.

内存占用最高的是chrome和gvfsd-metadata，前者1.6G没办法，后者竟然有1.8G。查了一下维基百科：

gvfsd-metadata is a daemon acting as a write serialiser to the internal gvfs metadata storage. It is autostarted by GIO clients when they make metadata changes. Read operations are done by client-side GIO code directly, and don’t require the daemon to be running. The gvfs metadata capabilities are used by the GNOME Files file manager, for example.

虽然仍然没搞懂它是个什么东西，但是罪魁祸首就是它没跑了，形成的原因大概是我打开过很多大的数据集的文件夹，比如pascal voc、shapenet、pascal3d，要是还有imagenet就更恐怖了。从这个帖子来看，它还导致了100%的CPU占用。后面给出了临时的解决办法：

rm -rf ~/.local/share/gvfs-metadatapkill gvfsd-metadata

如果这种情况继续出现，那么直接按照这里所说取消gvfsd-metadata的执行权限即可：sudo chmod -x /usr/lib/gvfs/gvfsd-metadata。

另外，iowait也达到了27%左右，我只不过开了个sublime-text而已。原因仍然是数据集，有好几个sublime_text --crawl的进程在不停地读磁盘，给文件做索引。这些数据集的文件格式大多是图片，所以只要按照这个帖子给sublime-text的配置加上：

"folder_exclude_patterns": [".svn", ".git", ".hg", "CVS", "node_modules/*"],"binary_file_patterns": ["*.mat","*.jpg", "*.jpeg", "*.png", "*.gif", "*.ttf", "*.tga", "*.dds", "*.ico", "*.eot", "*.pdf", "*.swf", "*.jar", "*.zip"],

问题就解决了。

不过对于ShapeNet这样的仍然没有办法==，所以最好还是避免用sublime-text打开带有数据集的文件夹（这种需要却并不少见，因为用软链接方便）。

Following the installation guide to install ork is very simple, don’t forget to install couchdb. Building from source is the only choice now, you have to modify the code to make it work as you wish.

In my case, tabletop method works well with KinectV1, even with KinectV2(but only the hd resolution config worked). However, linemod caused a huge memory leak, nearly 1GB/s, and it didn’t publish /recognized_object_array topic. At the beginning I thought it is the problem is in linemod, but it turned out to be in ork_renderer. A thread in ORK Google Group said,

Currently LINEMOD uses ork_renderer for its training phase. ork_renderer uses either GLUT or osmesa to generate synthetic images of the training data. It seems that the ork_renderer in your computer is linked to osmesa.

Fortunately now we just can change CMakeLists.txt to use GLUT. Just change option(USE_GLUT "Use GLUT instead of OSMesa" OFF) to option(USE_GLUT "Use GLUT instead of OSMesa" ON).

Update: Now I just use the version from JimmyDaSilva but not the official wg-perception.

But the current linemod version still have some problem related to assimp_devel, it seems the developer is working on it, you have to revert linemod to the previous version(35aebd).

So I just created a repo here to make the whole thing work. When linemod is training it will show a assimp window, but it do not contain anything in my case, not a serious problem, linemod works anyway with KinectV1, but not with KinectV2, because KinectV2 has a special resolution, causing an OpenCV error in linearMemoryPyramid. Fortunately again an awesome guy has worked it out, and he also fixed many other issues. I need to use KinectV2 in my work, so I followed this guy’s modification and successfully made it work on KinectV2 with QHD resolution. If you want to use SD resolution, you can set T={2,4} in linemod_detect.cpp and renderer_width: 512 renderer_height: 424 in training.ork as JimmyDaSilva said.

This ork repo integrated all of them, just to make it easier to work on ork, maybe for myself in the future.

Tips:

• If you used linemod to train, you’d better delete the whole object_recognition database in CouchDB.
• Using coke.stl is simpler, using coke.obj with texture will get a better result.
• When training linemod, make sure you are in the folder which contains the obj, mtl and image files.

而且，我还要在所有屏幕所有主机上共享一套鼠标和键盘！还要共享剪贴板，让文本可以直接从一个系统复制粘贴到另一个系统！

由于我有时用到自带屏幕的笔记本，我还需要有时台式机接双显示器，有时笔记本自带屏幕加一台显示器做双屏！

经过一番折腾，上述奇怪的需求全都实现了。这可以叫做多系统、多头、单尾的工作环境。5年前B哥的这篇文章第一次让我知道了计算机的头和尾。

Synergy是一个通过局域网实现的鼠标键盘共享软件。然而作为一个开源软件，它的下载竟然是收费的！虽然开源软件收费并不是什么坏事，然而开源软件本身是开源的，只要自己能编译出来或者使用别人编译的程序似乎也不违规？我对它的盈利模式深表怀疑。。。而且，Synergy也有Nightly Build是可以搜到的，也就是说你·根·本·就·可·以·免·费·下载到最新的版本（不过可能不够稳定）。

我尝试了Synergy的很多个版本，发现并不是很稳定，而且如果服务器和客户端是不同的版本会有不兼容的问题。最后找了一个老的版本以Daemon/Windows服务的形式运行，大概图形界面就是罪魁祸首吧，我也懒得去确定最新版本用这种方式能否稳定工作了。

所需硬件：

• 两台显示器
• 一台台式机
• 一台笔记本
• VGA切换器和若干线
• 局域网环境

所需软件：

• Synergy

Windows Synergy 1.6.2 http://down.tech.sina.com.cn/content/50073.html

Ubuntu Synergy 1.6.2 https://launchpad.net/ubuntu/+source/synergy/1.6.2-0ubuntu1

我把Windows用作客户端，Ubuntu作为服务器。不过Ubuntu的这个版本原本是给Vivid，即15.04用的，它需要4.9版本的g++，而我用的是Ubuntu 14.04，g++版本是4.8。那么，就装一个：

sudo add-apt-repository ppa:ubuntu-toolchain-r/testsudo apt-get updatesudo apt-get install g++-4.9

配置不多说，有图形界面，调一下hostname和显示器摆放位置就行了。调好配置文件保存一下，在/usr/share/lightdm/lightdm.conf.d/50-ubuntu.conf中加入：

greeter-setup-script=/usr/bin/synergys -c <CONFIG FILE>

这样，只要启动还未登录时鼠标和键盘就能共享了。

Windows客户端配置就更简单了，安装完就有synergy的系统服务。不过最好不要开图形界面，一开似乎就是运行了多个synergy，端口冲突，需要重新启动服务。

至于显示器的切换，我是在某宝上买了一个VGA切换器。其实某宝上还有卖鼠标键盘共享加多显示器切换的KVM切换器，但通过按按键让鼠标和键盘随显示器从一台主机切换到另一台主机更适合于多主机单头单尾的情况，而且听卖家说必须要接上两个主机供电，对于我来说显然用Synergy和VGA切换器更好一些。

台式机连接一台固定的显示器，另外抽一根VGA线连到切换器的输入，笔记本也连一根VGA线到切换器的输入，然后切换器输出VGA线连上的显示器就能用切换器上的按键切换主机了。Done。

（从右边屏幕Windows打开的pdf里复制一段代码移到左边屏幕Ubuntu的终端里粘贴执行，你知道这是多么巨大的工作效率提升么？！！！）

以下是算法流程，其实网上的类似博文已经很多了，只不过我看的过程中也看得不很明白，只能对照着好几个看，所以干脆自己又写了一遍。下面的图均来自于参考资料中，然而参考资料的图也是来自于参考资料的参考资料中。

1. 构建尺度空间

定理1 对图像做 $\sigma = \sigma_1$ 的高斯平滑，再做一次 $\sigma = \sigma_2$ 的高斯平滑，等效于对原图像做一次 $\sigma = \sqrt{\sigma_1^2+\sigma_2^2}$ 的高斯平滑。

1.1 构建高斯金字塔

高斯卷积核是实现尺度变换的唯一线性核（Koenderink, 1984; Lindeberg, 1994）。

一幅图像的尺度空间被定义为对其做可变尺度的高斯卷积：

对于给定的彩色图像，转化为灰度图像，用不同大小的$\sigma$做高斯平滑（按照 3$\sigma$ 准则，高斯核矩阵的大小设为 $(6\sigma+1)\cdot(6\sigma+1)$ ，并保证行和列为奇数），再此基础上将图像降采样得到不同大小的组(octave)，每组若干图像(interval)。详细描述如下：

为了得到更多的特征点，将图像扩大为原来的两倍。假设原图像已有 $\sigma=0.5$ 的高斯平滑，而我们需要第一个octave的第一张图像的 $\sigma=1.6$ ，按照定理1，我们要对扩大两倍的图像做一次高斯平滑，$\sigma=\sqrt{1.6^2-(0.5\times2)^2}$ 。

上一个octave的图像的长度和宽度分别是下一个octave的图像的两倍。因此图像组数(octaves)可由图像大小决定，将其设为 $log_2(min(height,width))$ $-\ 2$ ，这样将使顶层octave图像的长度和宽度最小值在8像素左右。

设第m个octave的第n张图像相对于原始图像的参数$\sigma$为 $sigma(m,n)$，则$sigma(1,1)=\sigma_0=1.6$。每个octave有s+1张图像（即intervals），这样得到的高斯差分金字塔(DoG)每个octave将有s张图像，我们设s为3。为了满足在不同octave间尺度的连续性，并使 $sigma(m,n)=$ $2 \cdot sigma(m-1,n)$，按照定理1，则：

如上图所示，在第一个octave中尺度为$k^3\cdot \sigma_0$的“最后”一张图像进行下采样得到第二个octave的第一张图像，尺度仍为$k^3\cdot \sigma_0=2\cdot \sigma_0$。

但实际上我们需要做出更多不同尺度的高斯平滑图像，这是因为在后续高斯差分金字塔的极值检测中，需要前后两级尺度都存在图像。如图中红框所示，高斯差分金字塔中每个octave有s幅图像，则需要高斯金字塔中每个octave包含s+3幅图像。其中第s+1幅图像用作下一个octave第一幅图像的降采样。

具体实现中并未对单幅图像多次进行高斯平滑，而是由上一幅图像进行高斯平滑得到下一幅图像并迭代之，按照定理1计算$\sigma$。

1.2 构建高斯差分金字塔

对两幅高斯金字塔的图像作差。

1.3 检测极值点

如上图，与前后两幅图像及自身的共26个邻域像素点比较灰度值检测极值。

2. 关键点精确定位

检测到的极值点是离散的，通过三元二次函数拟合来精确确定关键点的位置和尺度，达到亚像素精度。以某关键点为中心的尺度空间函数 $D(x,y,intvl)$ 的二次泰勒展开式为：

其中等号右边第一个D为某关键点处的灰度值， $\mathbf{X}=(x,y,intvl)^T$ 是以此点为中心的偏移量，由于 $D(\mathbf{X})$ 是离散的，其导数用差分法求得。令 $D(\mathbf{X})$ 导数为零，得到精确极值位置的偏移量为：

若$\mathbf{\hat{X}}$在任意一个维度大于0.5，说明极值点精确位置距离另一个点更近，应该将关键点定位于更近的那个位置。定位到新点后再进行相同操作，若迭代5次位置仍不收敛，则不认为此点为关键点。设定图像边缘img_border，若关键点落在图像边缘区域（以img_border为宽度的矩形外框）也不认为此点为关键点。

2.1 去除低反差(low contrast)的点

精确极值点处函数值：

若 $|D(\mathbf{\hat{X}})|<0.04/s$ ，同样不认为此点是极值点。在此过程中保存极值点的数据ddata，为特征的构建做准备。计算出$\sigma\_octv$，即位于一个相同的octave内的尺度，某个octave内第n张图像的 $\sigma\_octv= \sigma_0\cdot k^{intvl-1}$ ，此处intvl为精确定位后的intvl。

2.2 消除边缘响应

高斯差分函数有较强的边缘响应，对于比较像边缘的点应该去除掉。这样的点的特征为在某个方向有较大主曲率，而在垂直的方向主曲率很小。

设r为大主曲率与小主曲率的比值，H为关键点处的Hessian矩阵，则有（具体推导可见Lowe的论文）：

若满足：

说明此处r较小，认为此关键点不位于边缘，否则则去除该点。

3. 方向指定

根据关键点的局部特性为每个关键点指定一个方向，可以具备旋转不变性。关键点局部特性在检测到关键点的高斯差分金字塔图像临近的高斯金字塔图像中计算。在关键点3σ邻域窗口计算梯度和方向分布，计算方式如下：

此处的x正方向向右，y正方向向上。其中L为关键点在上述精确定位后所处尺度的灰度值，m(x,y)为梯度的幅值，$\theta(x,y)$为关键点处梯度方向的弧度（范围为$(-\pi,\pi]$）。将360度的方向划分为36个区域(bins),第一个区域的范围是$[\frac{35\pi}{36},\frac{37\pi}{36})$,按逆时针方向依次划分。对m(x,y)按 $\sigma=1.5\sigma\_octv$ 的高斯分布，在 $3\sigma=3\cdot1.5\sigma\_octv$ 的邻域窗口加权计算，得到36个方向的直方图。然后对直方图进行两次平滑处理，即按0.25,0.5,0.25的大小对每3个连续的bin加权两次。

直方图最大值的方向代表该关键点的主方向，对于其他峰值，若大于或等于主方向值的80%，则再分配一个方向。所以对于一个关键点，可能会有多个对应的方向，将带有方向的关键点定义为feature，则一个关键点可能对应多个feature。由于第一个octave是双倍大小的图像，feature的坐标和尺度应转换到原始图像所在的octave处理。最后用抛物插值精确定位feature的方向。

对于x为-1,0,1，y为l,c,r的三个点来说，抛物插值得到极值点的x为：

4. 关键点描述子

上一步已得到具有主方向的关键点，即feature，下一步是对feature的邻域进行采样，形成对该局部图像的描述，然后可用某种度量方法对描述进行匹配。
Lowe提出的sift描述子是一个 $4\times4\times8=128$ 维的向量。描述子的数学形式可定义为 $h(x,y,\theta)$ ，其中的x,y代表 $4\times4=16$ 个图像区域的位置，$\theta$即梯度方向，只能取8个值。$h(x,y,\theta)$的值就是在(x,y)代表的图像区域计算得到的在$\theta$方向的梯度大小。

4.1 描述子采样区域

这16个图像区域中的每一个区域均为 $3\sigma\_octv$ 像素，因此16个区域的半边长为 $4\times3\sigma\_octv/2$ ，考虑到后续操作需要三线性插值，采样区域半边长设为 $(4+1)\times3\sigma\_octv/2$ ，又由于旋转操作，这个值需要乘以$\sqrt{2}$，得到 $radius=(4+1)\times$ $\sqrt{2}\times3\sigma\_octv/2$ 。

如下图所示，图中 $m=3,$ $B_p=4,\sigma=\sigma\_octv$ 。

4.2 旋转至主方向

为了使描述符具有旋转不变性，将坐标轴旋转至关键点主方向。设i，j分别为采样点相对关键点的行偏移量和列偏移量，i = -radius:radius，j = -radius:radius，关键点左上角i和j均为负数。关键点主方向为$\theta$，范围是$(-\pi,\pi]$。

定理2 在右手平面直角坐标系中，向量(x,y)逆时针旋转$\theta$，得到的向量(x’,y’)为：

$$\begin{bmatrix} x'\\ y' \end{bmatrix} =\begin{bmatrix} cos\theta & -sin\theta \\ sin\theta & cos\theta \end{bmatrix} \begin{bmatrix} x\\ y \end{bmatrix}$$

在左图以关键点为中心建立右手平面直角坐标系o-uv，u的正方向与左图$\mathbf{x}$方向相同，v的正方向与左图$\mathbf{y}$方向相反。左图中$\mathbf{x}$=(1,0),$\mathbf{y}$=(0,-1)，将$\mathbf{x}$,$\mathbf{y}$代入定理2的公式，得到右图中 $\mathbf{x'}=(cos\theta,sin\theta),$ $\mathbf{y'}=(sin\theta,-cos\theta)$ 。其中$\theta$为左图坐标系旋转到右图坐标系的角度，在上图中为一负数。设图像中有一点按左图的$\mathbf{x}$,$\mathbf{y}$可表示为 $j \cdot\mathbf{x} + i\cdot\mathbf{y}$ ，按右图中的$\mathbf{x'}$,$\mathbf{y'}$可表示为 $j'\cdot\mathbf{x'}+i'\cdot\mathbf{y'}$ ，则有：

解得 $j'=j\cdot cosθ-i\cdot sinθ,$ $i'=j\cdot sinθ+i\cdot cosθ$ 。

得到新的行、列偏移量后，将 $3\sigma\_octv$ 设为单位长度，并将中心转移至最左上角区域中心，得到新的坐标r_bin和c_bin。对梯度方向弧度值减去主方向弧度，并设 $\frac{2\pi}{8}$ 为一个单位，得到o_bin。

采样点的梯度幅值按照 $\sigma=0.5\cdot4\cdot3\sigma\_octv$ （即16个区域边长的一半）的高斯函数加权：

其中a，b为关键点在高斯金字塔图像中的位置坐标。

4.3 三线性插值

上述过程中构造了一个三维的bin空间，如4.1中右图所示，维度包括r_bin，c_bin和o_bin。注意最上层格子和最底层格子是相连的，因为0度等于360度。所有带有三维坐标的梯度幅值都将分配到三维格子里。

为了减少一个梯度幅值从一个格子漂移(shift)到另一个格子引起的描述子突变，需要对梯度值做三线性插值。也就是根据三维坐标计算距离周围格子的距离，按距离的倒数计算权重，将梯度幅值按权重分配到临近的格子里。

某点在三维bin空间的坐标为$(r\_bin，c\_bin，o\_bin)$，求出$r=\lfloor r\_bin\rfloor,$ $c=\lfloor c\_bin\rfloor,$ $o=\lfloor o\_bin\rfloor,$ $dr=r\_bin-r,$ $dc=c\_bin-c,$ $do=o\_bin-o$，它的梯度幅值最多可能分配到周围的8个格子中。计算公式如下：

其中i，j，k均可取0或1，weightedValue下标加1的目的是使下标从1开始。

为简化计算，可改为：

4.4 生成描述子

将上述直方图数组按顺序排列可转换为一个128维的向量。

为了减少光照变化的影响，对该向量进行归一化处理。非线性光照变化仍可能导致梯度幅值的较大变化，然而影响梯度方向的可能性较小。因此对于超过阈值0.2的梯度幅值设为0.2，然后再进行一次归一化。最后将描述子按照对应高斯金字塔图像的尺度大小排序。

5. 匹配

描述子向量已经归一化，所以可直接用向量之间的夹角进行匹配，相当于球面距离。图像A 的描述子匹配图像B最近的两个描述子点积之比小于0.6，则认为匹配成功。

6. 一些废话

6.1 性能优化

因为用的是Matlab，所以不注重性能。然而又不得不注重性能，因为第一次跑通程序的时候跑了一晚上都没跑完一半！也就是一张图片的描述子都没算完。后来发现是因为在运行次数最多的for循环(描述子计算中的梯度计算)里用到了cell数组。把对这个cell数组的查询操作提到两重循环前以后，这个程序好像跑了半个小时左右跑出结果了。然而还是太慢，于是我又用Matlab的计时分析工具分析了程序最耗时的地方:

• 把cell数组的查询尽可能减少
• 充分利用Matlab的向量操作
• 一些没用的参数给去掉了（如计算梯度时的三个返回值合并到了一个二维数组）
• 一个三维数组折叠成了一维的（hist）

程序里用了很多全局变量，是因为我把函数分成了文件而不是放在一个文件，为了节省点内存（以及方便）只能这么做（虽然据说Matlab在不改变变量的情况下函数传值等于引用，然而我并不清楚究竟是怎样的）。把for循环换成parfor的时候提示，parfor里似乎不推荐用全局变量，而且实际运行的时候全局变量似乎也会影响性能，于是我把全局变量复制成了局部的再放进parfor里。

我还发现一个奇葩的问题，在运行次数最多的计算梯度的函数里用zeros(1,2)创建一个数组竟然也耗时非常多，改成[0 0]就好了。

经过这些修改后，在开启parallel pool的情况下运行时间缩短到了7分钟左右。（然而Lowe的C语言版本只要十几秒

6.2 运行结果

这次作业老师给的是两张768x1024的图片，分别检测到5288和4798个特征点，最后匹配了906对点。用Lowe的siftDemoV4跑出来的结果是1252对匹配。

这个程序的参数基本都是参照opensift，但最后的匹配用的是Lowe的方案。Lowe的实现毕竟不太一样，运行的结果和opensift有一些差异。以下是匹配siftDemoV4.zip里的scene.pgm和book.pgm的结果：

sw-sift和opensift的区别主要是在高斯平滑和匹配算法上。opensift的高斯平滑用的是OpenCV的CVSmooth函数，匹配用的是欧式距离（而且把描述子乘以512从double类型转成了int）。和opensift相比，sw-sift检测到的特征点数量很接近，但是匹配数量较少，所以可改进的地方主要是匹配算法（然而我不想改了==）。另外，我发现高斯平滑的核矩阵大小对结果有很大影响，根据$3\sigma$准则它的宽度应该是 $(6\sigma+1)\cdot(6\sigma+1)$ ，然而有人设成 $(3\sigma+1)\cdot(3\sigma+1)$ 却取得了更多特征点，因此调整这个参数再用其它参数限制错误数量或许可以得到更好的结果。

6.3 源代码

代码发布在github: sw-sift，请注意sift是有专利的。

参考资料

David G. Lowe, “Distinctive image features from scale-invariant keypoints,” International Journal of Computer Vision, 60, 2 (2004), pp. 91-110. [PDF] [CODE]
Rob Hess, OpenSIFT源码: https://github.com/robwhess/opensift
zddhub, SIFT算法详解: http://blog.csdn.net/zddblog/article/details/7521424
Rachel Zhang, SIFT特征提取分析: http://blog.csdn.net/abcjennifer/article/details/7639681
JiePro, SIFT算法：特征描述子: http://www.cnblogs.com/JiePro/p/sift_4.html

1. Caffe依赖包

1
2

sudo apt-get install build-essential  # basic requirement
sudo apt-get install libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libboost-all-dev libhdf5-serial-dev libgflags-dev libgoogle-glog-dev liblmdb-dev protobuf-compiler #required by caffe

2. 安装CUDA 7.5

2.1 禁用nouveau驱动

我作死地相信了上述第二篇文章的话，没有禁用nouveau驱动，结果第一次重启神奇地成功了，第二次重启就无法登陆。。。后来用recovery mode禁用了nouveau。所以一定要禁用nouveau：

创建文件/etc/modprobe.d/blacklist-nouveau.conf

blacklist nouveauoptions nouveau modeset=0

2.2 安装CUDA

在NVIDIA开发者官网下载CUDA 7.5，我直接用的deb包，因为觉得比较方便。可以直接双击打开安装，也可以用命令行：

1
2
3

sudo dpkg -i cuda-repo-<distro>_<version>_<architecture>.deb
sudo apt-get update
sudo apt-get install cuda

都说要禁用lightdm安装cuda，但是用deb包安装的话没有关掉lightdm也没有遇到什么问题。安装完CUDA以后使用的就是nvidia闭源驱动了。

2.3 配置环境变量

在/etc/profile中添加：

1

export PATH=$PATH:/usr/local/cuda/bin

创建文件/etc/ld.so.conf.d/cuda.conf:

/usr/local/cuda/lib64

使上述配置直接生效：

1
2

source /etc/profile
sudo ldconfig

2.4 编译SAMPLE

进入/usr/local/cuda/samples:

1

sudo make all -j4

完成后进入samples/bin/x86_64/linux/release:

1

./deviceQuery

可以看到你的显卡信息（其实并没什么卵用。

3. 安装cuDNN

cuDNN要注册NVIDIA开发者账号才能下载，我注册了下很快就收到邮件可以下载了，但是蛋疼的intel MKL至今都没收到回复下载不了。。。

这个比较简单，下载下来直接是编译好的lib和include，丢进/usr/local/cuda里就行了：

1
2
3
4

cd cudnn-* #下载解压后的文件夹
sudo cp lib64/* /usr/local/cuda/lib64/
sudo cp include/* /usr/local/cuda/include/
sudo ldconfig

如果你遇到/sbin/ldconfig.real: /usr/local/cuda/lib64/libcudnn.so.5 is not a symbolic link这样的问题，重新链接一下(根据版本自行调整)：

1
2
3

cd /usr/local/cuda/lib64
sudo ln -sf libcudnn.so.5.1.3 libcudnn.so.5
sudo ln -sf libcudnn.so.5 libcudnn.so

4. 安装BLAS

为在intel网站申请学生版始终没回复，所以就只有用OpenBLAS了。。。
Intel的MKL在这里注册一下也能用，有图形界面，安装完成之后创建文件/etc/ld.so.conf.d/intel_mkl.conf：

/opt/intel/lib/intel64/opt/intel/mkl/lib/intel64

然后sudo ldconfig。

OpenBLAS安装如下：

1
2
3
4

git clone https://github.com/xianyi/OpenBLAS.git
cd OpenBLAS
make -j4
sudo make install PREFIX=/usr/local/openblas

创建文件/etc/ld.conf.d/openblas.conf:

/usr/local/openblas/lib

5. 安装Anaconda

我是直接用pyenv安装的，因为需要在多个python环境下切换。其实一开始直接编译安装了Anaconda后来发现pyenv又删掉了…

5.1 安装pyenv

1
2
3
4
5

git clone https://github.com/yyuu/pyenv.git ~/.pyenv
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(pyenv init -)"' >> ~/.bashrc
exec $SHELL -l

5.2 用pyenv安装Anaconda

如果觉得网络不好可以直接把anaconda的sh文件下载下来放到~/.pyenv/cache里。

1
2
3

pyenv install anaconda2-4.1.0
pyenv global anaconda2-4.1.0
pyenv versions

这时你应该可以看到你切换到anaconda2-4.1.0了。另外还可以用pyenv-virtualenv，不过我没有折腾。

6. 安装OpenCV

方案一：

1
2
3

sudo add-apt-repository --yes ppa:xqms/opencv-nonfree
sudo apt-get update
sudo apt-get install libopencv-nonfree-dev libopencv-nonfree2.4

方案二：

有个安装脚本，不过靠脚本安装OpenCV毕竟太不靠谱，我是看着脚本一点点自己敲命令装好的。直接把脚本贴上来吧：

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

arch=$(uname -m)
if [ "$arch" == "i686" -o "$arch" == "i386" -o "$arch" == "i486" -o "$arch" == "i586" ]; then
flag=1
else
flag=0
fi
echo "Installing OpenCV 2.4.10"
mkdir OpenCV
cd OpenCV
echo "Removing any pre-installed ffmpeg and x264"
sudo apt-get -y remove ffmpeg x264 libx264-dev
echo "Installing Dependenices"
sudo apt-get -y install libopencv-dev
sudo apt-get -y install build-essential checkinstall cmake pkg-config yasm
sudo apt-get -y install libtiff4-dev libjpeg-dev libjasper-dev
sudo apt-get -y install libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev libxine-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev
sudo apt-get -y install python-dev python-numpy
sudo apt-get -y install libtbb-dev libeigen3-dev
sudo apt-get -y install libqt4-dev libgtk2.0-dev
sudo apt-get -y install libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev
sudo apt-get -y install x264 v4l-utils ffmpeg
sudo apt-get -y install libgtk2.0-dev
echo "Downloading OpenCV 2.4.10"
if ! [ -f "OpenCV-2.4.10.zip" ]; then
  wget -O OpenCV-2.4.10.zip http://sourceforge.net/projects/opencvlibrary/files/opencv-unix/2.4.10/opencv-2.4.10.zip/download
fi
echo "Installing OpenCV 2.4.10"
if ! [ -d "opencv-2.4.10" ]; then
  unzip OpenCV-2.4.10.zip
fi
rm OpenCV-2.4.10.zip
cd opencv-2.4.10
rm -rf build
mkdir build
cd build
cmake -D CUDA_ARCH_BIN=3.2 -D CUDA_ARCH_PTX=3.2 -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D BUILD_TIFF=ON -D WITH_QT=ON -D WITH_OPENGL=ON ..
make -j
sudo make install
sudo sh -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'
sudo ldconfig
echo "OpenCV 2.4.10 ready to be used"

前面的安装依赖包倒没什么，到了25行wget opencv的时候发现sourceforge的下载链接已经变了，下不下来，于是到sourceforge.net把OpenCV 2.4.10下下来，再命名成脚本需要的OpenCV-2.4.10.zip（注意大小写，如果你需要按脚本来的话）。

其实已经基本不需要这个脚本文件了，直接一点点敲命令来吧。

1
2
3
4
5
6
7
8

cd opencv-2.4.10
mkdir build
cd build
cmake -D CUDA_ARCH_BIN=3.2 -D CUDA_ARCH_PTX=3.2 -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D BUILD_TIFF=ON -D WITH_QT=ON -D WITH_OPENGL=ON ..
make -j4
sudo make install
sudo sh -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'
sudo ldconfig

7. 安装Caffe

终于能装Caffe了，不过先要安装python依赖库。进入caffe安装目录下的python文件夹：

1

for req in $(cat requirements.txt); do pip install $req; done

修改Makefile.config，注意需要的几项就行：

# cuDNN acceleration switch (uncomment to build with cuDNN).USE_CUDNN := 1# CUDA directory contains bin/ and lib/ directories that we need.CUDA_DIR := /usr/local/cuda# BLAS choice:# atlas for ATLAS (default)# mkl for MKL# open for OpenBlasBLAS := mkl# This is required only if you will compile the matlab interface.# MATLAB directory should contain the mex binary in /bin.MATLAB_DIR := /usr/local/MATLAB/R2016b# Anaconda Python distribution is quite popular. Include path:# Verify anaconda location, sometimes it's in root.ANACONDA_HOME := $(HOME)/.pyenv/versions/anaconda2-4.1.0PYTHON_INCLUDE := $(ANACONDA_HOME)/include \    $(ANACONDA_HOME)/include/python2.7 \    $(ANACONDA_HOME)/lib/python2.7/site-packages/numpy/core/include \# PYTHON_LIB := /usr/libPYTHON_LIB := $(ANACONDA_HOME)/libWITH_PYTHON_LAYER := 1

上面的并不是完整文件，只是贴出来需要修改的几项。若使用matlab，注意要把matlab加入PATH环境变量，如在/etc/profile中加入export PATH=$PATH:/usr/local/MATLAB/R2016b/bin。如果你的BLAS选择的是openblas，那在BLAS := open后面应该加上:

# Custom (MKL/ATLAS/OpenBLAS) include and lib directories.# Leave commented to accept the defaults for your choice of BLAS# (which should work)!BLAS_INCLUDE := /usr/local/openblas/includeBLAS_LIB := /usr/local/openblas/lib

最后编译caffe:

1
2
3

make all -j4
make test -j4
make runtest

如果还需要python或者matlab接口(需确保Makefile.config中的python和matlab路径正确)：

1
2

make pycaffe
make matcaffe

如果在make runtest的时候遇到error while loading shared libraries: libhdf5_hl.so.10: cannot open shared object file: No such file or directory类似的错误，为了避免冲突尽量不要把anaconda的lib路径(即上面的~/.pyenv/versions/anaconda2-4.1.0/lib)添加到LD_LIBRARY_PATH，因为其它软件可能需要系统自带的python而不是anaconda。在/usr/lib/x86_64-linux-gnu下面可能有libhdf5_hl.so.7，版本太低了。

我是这样做的：

1
2
3
4
5
6

cd /usr/lib/x86_64-linux-gnu/
sudo cp ~/.pyenv/versions/anaconda2-4.1.0/lib/libhdf5.so.10* .
sudo cp ~/.pyenv/versions/anaconda2-4.1.0/lib/libhdf5_hl.so.10* .
cd /usr/lib/x86_64-linux-gnu/
sudo ln -sf libhdf5.so.10.1.0 libhdf5.so.10
sudo ln -sf libhdf5_hl.so.10.0.2 libhdf5_hl.so.10

或者更直接的方法是修改caffe的Makefile？

如果还有部分runtest失败：

[  FAILED  ] SGDSolverTest/0.TestSnapshotShare, where TypeParam = caffe::CPUDevice<float>[  FAILED  ] AdaGradSolverTest/0.TestSnapshotShare, where TypeParam = caffe::CPUDevice<float>[  FAILED  ] NesterovSolverTest/0.TestSnapshot, where TypeParam = caffe::CPUDevice<float>[  FAILED  ] NesterovSolverTest/0.TestSnapshotShare, where TypeParam = caffe::CPUDevice<float>[  FAILED  ] AdaDeltaSolverTest/0.TestSnapshotShare, where TypeParam = caffe::CPUDevice<float>[  FAILED  ] AdamSolverTest/0.TestSnapshotShare, where TypeParam = caffe::CPUDevice<float>[  FAILED  ] RMSPropSolverTest/0.TestSnapshotShare, where TypeParam = caffe::CPUDevice<float>

在/etc/profile加入：

1
2

export CUDA_VISIBLE_DEVICES=0
export MKL_CBWR=AUTO

别忘了source /etc/profile。

基于基于Landscape主题的Landscape-Plus主题修改而来的主题，带有几张纸和一个会动的纸盒子。

3年前折腾Hexo的时候看到自带的light主题，风格很喜欢，感觉很简洁，只是有点太简洁了…

于是自己动手改造。发现light主题的文章背景和widget背景都有点像纸的样子，就有了个想法，把所有的东西都变成纸！碰巧在cssdeck看到了一个很酷的用CSS做成的立方体，于是直接拿来做成了一个纸盒子，即Paperbox。然后给文章的白色背景增加了卷起边角的阴影，这就是当时的Paperbox主题：

然而当时对移动设备的响应式设计几乎一无所知，所以这个主题在移动设备下简直就是一团糟。。。后来Hexo2.4以后有了Landscape主题，于是我就把Paperbox再修改了一次，不过当时精力有限对github的操作也是每次用了就忘，木有上传更新代码。。。只用到了自己的博客上。

有一篇关于苹果网站首页CSS特效的文章，用这个效果替换了原来的边角卷起（原来的边角卷起在文章内容比较长的时候貌似会出现问题）。然后用上了CSS的动画让纸盒子动了起来，主导航栏也重新设计了一下，效果就跟现在的一样。不过这样的主题仍然存在不少bug，很多主题在PC上看起来很正常，但是到了宽度只有320点的iPhone 4-5s上面的时候就各种毛病了。。。

然后。。。就到了现在，来填坑了。。。

时间已经是2016年，Hexo已经进化到了3.1.1。。。作者更新得真他妈快。。。

Landscape有了一个叫做Landscape-plus的衍生主题，有不少功能增强，所以我就以它为起点，把原来的外观再照搬过去。不过搬过去的过程中发现不少显示细节上的问题，强迫症不能忍…比如，把浏览器窗口缩小至移动设备大小，点开导航按钮，然后再最大化。。。（完全不是一个正常用户干的事！蛇精病!)，不过我就是不能忍地把它给修复了。。。

还有，页面里每个文章都有分享按钮，如果点了一篇文章的分享按钮不关闭，再点另一个分享按钮不关闭，回来再点原来文章的分享按钮，突然失灵了。。。（同样蛇精病！）但我还是不能忍地修好了。。。

还有底部分页器（Paginator）的...在移动设备界面也显示出来，我把它给隐藏了。。。

还有很多这样的小细节问题，都给解决了。

最头疼的是mathjax的公式，因为不管怎么改CSS我发现公式太长都会溢出文章元素外，后来改用catx的hexo-math插件，加上这句css：

1
2

.MathJax_Display
    overflow-x: auto

就解决了。。。(不过在某些渲染器下不存在这个类，这我就撒手不管了…)

另外对主题原生的分享按钮做了增强，把Pinterest换成了Linkedin，毕竟Pinterest上的大多都是图片。。。然后加上了国内的四个社交网站，微博，人人，QQ空间，微信，用jquery的qrcode插件生成文章链接的QR码用来做微信的分享。百度的那个分享感觉太累赘（而且还有js的warning），还和swiftype有冲突，干脆就删掉了。

文章目录（TOC）的添加是参考的这篇文章。

最后来测试一下Mathjax的公式显示：

Rosmin demo:

Rosmin

项目地址：https://code.google.com/p/wtfrobot-rosmin/

相关文章：

Rosmin—OpenCV Color Blob Tracker on Android

Android下PocketSphinx的离线语音识别

Rosmin—OpenCV Color Blob Tracker on Android

Rosmin—两台Android手机的Socket双向通信

Rosmin—在Android上绘制小车行进路线图并标记

Rosmin—折腾USB Host Shield的日子

Rosmin机器人是我们去年（2012年）制作的一个使用Arduino驱动的小型移动机器人，连接上Android手机，可以完成手机控制的基本运动，追踪乒乓球，以QR码为人工路标移动到指定区域，搜寻目标，视频监控等等。

硬件结构：

软件结构：

• 图像处理

  利用Android版OpenCV的ColorBlobTrack，控制舵机追踪乒乓球一类有明显颜色特征的物体。

• 语音识别

  利用CMU Sphinx语音库实现的小范围离线语音识别，识别速度、准确度都还不错，而且是离线的，不需要连接网络。

• Google ADK Mega2560

  使用Google ADK Mega2560 通过USB线与Android手机相连，让小车由小车上搭载的手机运行的服务端程序控制，另外另一台Android设备通过WiFi连接到小车上的手机作为客户端可对小车远程控制。

• 陀螺仪

用陀螺仪的角加速度信息计算出角度，综合手机发出的控制命令绘制小车运行轨迹。

实现的功能有：

1. 基本运动：用Android设备控制小车完成基本运动，可以用控制界面的按钮和语音来操控。如前进，后退，停止，左转，右转，车身左转90度，车身右转90度，舵机云台的转动等。

2. 追踪乒乓球： 由小车上的Android手机做图像处理获取小球坐标，通过Arduino控制舵机对正小球。根据小球偏离中心位置的距离调整运动速度。详见这篇：Rosmin—OpenCV Color Blob Tracker on Android
   

3. 以QR码为人工路标的导航： 我们设计了一个以QR码作为人工路标的导航策略，根据超声波传感器检测拐角，利用QR码提供的信息和陀螺仪传感器的信息运动到指定区域。会有一篇水论文，不过现在还没发出来。
   

4. 绘制运动轨迹： 我们利用Android上的Google Maps控件做了一个绘制小车运动轨迹的程序，由小车上手机陀螺仪获取角加速度，计算出角度。不知是我们算法不行还是手机加速度计不够精确，用加速度计算出的里程误差太大根本用不了。于是我们就给小车一个恒定的速度，综合控制命令的信息（比如前进后退停止）来绘制轨迹。在客户端可以显示出小车的运行轨迹，还有QR码路标和目标的位置。详见这篇：在Android上绘制小车行进路线图并标记
   

5. 寻找目标： 不断转动寻找目标，发现目标以后就向目标前进。根据目标区域面积判断是否足够靠近，足够靠近了就认为到达了目标自动停止。关于怎么检测目标和计算目标区域面积仍然在：Rosmin—OpenCV Color Blob Tracker on Android
   

6. 视频监控： 用手机的WiFi Camera应用即可，可以通过PC端的Web界面控制。
   

Rossum

项目地址：https://code.google.com/p/wtfrobot-rossum/

相关文章：

Rossum—Android上ROS开发介绍与安装简介

Rossum—PID与里程计

Rossum—slam

Rossum—Android上ROS开发——android_core创建一个android应用

Rossum—ROSjava-android控制ROS机器人

Rossum—ROSjava的消息发送

Rossum—tpofinder 平面纹理物体识别

Rossum是我们以ROS机器人操作系统为核心做的一个自主导航机器人，名字来自于《罗萨姆的万能机器人( Rossum’s Universal Robots)》里的Rossum一词。使用 Kinect 传感器模拟激光测距仪,Arduino 控制器驱动电机控制机器人运动,Atom上网本置于机器人内作为主要的处理设备。

实现的功能：

1. 基本运动控制： 机器人运动模式为轮式运动,由两个驱动轮驱动机器人运动,一个万向轮辅助,采用 PI 反馈,闭环控制机器人速度,可以精确平滑地控制机器人的运动,同时利用编码器获取的数据,由运动学模型推算机器人的当前坐标系位姿。

2. 语音控制： 通过 Android 手机发送语音控制机器人运动,可进行离线英文语音识别(和Rosmin相同)，在线中文语音识别(讯飞)。

3. 跟随运动： 即turtlebot_follower，使机器人与人保持一定距离并正对人体,当人转向或移动时,机器人相应跟随人体转向和移动。

4. 同时定位与地图构建(SLAM)： 移动机器人在未知环境中依靠传感器获取的信息进行环境建模,同时利用所创建的环境地图估计其本身的位姿。

5. 自主导航： 在构建出静态地图的基础上,实现机器人从一个位置运动到地图上的另一个指定位置。

6. 物体识别： 利用tpofinder,实现识别有纹理特征的物体,如书本封面,咖啡盒等，识别后用TTS发声，通过舵机云台对准物体。详见：Rossum—tpofinder 平面纹理物体识别

最开始确定方案的时候我们找到了Dr. Rainer Hessmer的一篇文章,它是用Kinect来模拟激光测距仪来做SLAM的，里程计只靠电机上的编码器。他的博客上讲得非常详细，Arduino的介绍，Kinect模拟激光测距仪，惯性导航，SLAM和路径规划的参数这些全都有。当时我们啥都不懂，就把他的博客打印出来一篇一篇地看。

由于时间很紧，而且在机器人功能还没完全实现前就要写各种文档，我们真正用在这个机器人身上的开发时间很少，甚至可能不如Rosmin，但这个项目却是准备时间最长的，从一开始接触ROS，Android编程，Python，长时间犹豫不决地选购底盘，到后来的调试SLAM耗时有半年，调试SLAM和导航实际时间也就一个多月。

一开始我还想在ARM上实现它。那个时候ROS的网站上还没有Ubuntu ARM的源，但是刚刚发布ROS Groovy，把构建工具由rosbuild改成了catkin，还给出了详细的编译步骤。于是我就照着步骤编译了一下，核心包比较顺利地编译成功了。不过现在即使官方网站有源了，除了核心的库外，其它比较上层的包多数都没有构建成功。用它来做难度太大，而且性能不太好，于是我还是放弃了。图个方便不想遇到驱动问题，而且那时侯我们时间也比较紧了，所以没用mini-itx主板什么的，直接用了10寸的Atom上网本。至于底盘，在ROS的qq群里刚好发现有人出售专门用于ROS的机器人底盘Boomerang，于是我们就直接买了，包括它整个亚克力板的外壳和两个带编码器的电机、轮子。

虽然我们找到了这么详细的教程，不过要适配上我们的机器人硬件仍然有很多麻烦。Dr. Rainer Hessmer使用的ros版本是electric，而我们要用fuerte，有一些代码要改，比如参数的双引号什么的。还有一些包被废弃了，改名了，要把launch文件改一下。还有Kinect放置的位置和轮子的距离参数之类的，里程计的调试耗费了最长时间。但是编码器精确度有限，到最后里程计也还是很不准的。在我们视频里可以发现，其实机器人的位置估计是很不准的，万幸的是可以用SLAM算法纠正过来，在SLAM建图的时候注意对准拐角，建出的地图勉强可用，我们还可以用GIMP或者其它图片编辑工具小小滴修正一下，用来导航效果还行。SLAM的参数我们一开始尝试调过，不过后来觉得调整的意义不大，因为Dr. Rainer Hessmer做的已经很好了，我们效果没他的好主要原因应该是里程计。关于PID和里程计：http://blog.csdn.net/xiaoqiaoaidianzi/article/details/9179809/,slam:http://blog.csdn.net/xiaoqiaoaidianzi/article/details/9190829/

地图手工修正前后对比：

最后，其实我开始想实现的远远不止这些，我还想用OpenCV的blob检测来绘制出空中乒乓球的运动轨迹，利用运动轨迹做一些有意思的事情，让机器人具有简单的“认知”，还有三维的rgbd-slam，还有PCL的三维物体识别，还有利用语音识别让机器人完成一些有逻辑的任务，可惜时间远远比我们预料的少，遇到的问题远远比我们预料的多，我们的精力也有限，仍然有一些遗憾吧，现在我们WTFRobot团队的三人都已经加入考研大军了。

ROS（Robot Operating System）是一个开源的为机器人软件开发设计的软件框架，在异构计算机集群中提供类似操作系统的功能。它并不是一个计算机的操作系统，而是机器人的操作系统，或者称为元级操作系统（Meta Operating System）。据目前唯一一本比较官方的关于ROS的书《ROS By Example Volume 1》介绍，“The primary goal of ROS (pronounced “Ross”) is to provide a unified and open source
programming framework for controlling robots in a variety of real world and simulated
environments.”，ROS的原始目的就是为了在一系列真实和模拟的环境中控制机器人提供一个统一的开源编程框架。为了实现这一目标，ROS架构中有三个层次的概念：文件系统级（Filesystem Level），计算图级（Computation Graph Level）和社区级（Community Level）。
具体可以查阅维基百科和官网wiki，这里就不过多介绍了。

2. ROS Groovy Galapagos

ROS Groovy Galapagos是2012年12月31日发布的ROS最新版本，主要支持Ubuntu 11.10、Ubuntu 12.04和Ubuntu 12.10。提到这个版本的原因是它采用了新的构建系统——catkin，准备逐渐取代之前的rosbuild。它解决了rosbuild当中的几个问题，让ROS可以持续发展和扩大规模，相对于rosbuild更符合文件系统层次结构标准（Filesystem Hierarchy Standard，FHS），使在其它操作系统和架构上发布ROS包更加容易。正是这个原因让我在MK802 IIIS上编译ROS的时候轻松很多，如果编译之前的版本（比如fuerte）将会遇到更多问题。

因为catkin的引入，ROS文件系统级的Stacks概念被移除了，原因是Package和Stack之间依赖性跟踪出现的问题，取代的是元包（metapackage）的概念。

3. Ubuntu on ARM

ARM版Ubuntu的软件源是在http://ports.ubuntu.com/上，和桌面版的略有区别，我遇到的一个问题就是桌面版python-*的包ARM版几乎都没有，解决办法是使用python的包管理工具pip安装，比如桌面版上apt-get install python-PACKAGENAME，用pip install PACKAGENAME替代。据说easy_install的维护不够好，所以应该尽量用pip。

我使用的是RK3066上的Picuntu，关于Picuntu请看前一篇文章。

4. 编译ROS for ARM

从前为ARM编译一般都需要在x86的上位机上交叉编译，有一个叫做EROS的项目,但是似乎文档不全，个人觉得用它成功编译的人应该也不多。近几年ARM性能足够强了，在ARM运行的操作系统上直接编译也不是什么问题。所以完全可以参考官网从源码编译的教程，官网还特别搞了一个在树莓派上编译的教程。

当然，树莓派的内存只有512MB，而且是ARM 11，使用ROS会受到很大的限制，既然它都可以编译ROS Groovy，那么双核A9的RK3066，1G内存就更不是问题了。

下面一步步按照官网上从源码编译的wiki来：

4.1 安装基础依赖包

操作系统相关的：

sudo apt-get install build-essential git python-pip

ROS Common（或者叫ROS Base，Base Bones什么的）依赖的：

sudo apt-get install libtinyxml-dev libgtest-dev  liblog4cxx10-dev

注意这里只是在Picuntu RC2 上需要额外安装的库，可能你还会遇到其它库的问题。desktop或者desktop-full依赖的库更多，所以更难解决。

还有一些重要的工具：

sudo pip install wstool rospkg rosdep

可能会遇到很多python-*的包缺少的问题，需要用sudo pip install PACKAGENAME安装

安装完rosdep以后初始化一下：

sudo rosdep initrosdep update

4.2 构建catkin包

上面提到过，ROS Galapagos采用了新的构建工具catkin代替rosbuild，但并不是所有的包都转换成了catkin的版本，所以先构建ROS的核心包（使用catkin），然后再构建其余的使用rosbuild的部分。

4.2.1 创建catkin工作空间

mkdir ~/ros_catkin_wscd ~/ros_catkin_ws

下一步是下载核心包的源码并构建它们，你有三种选择：

Desktop-Full Install: ROS, rqt, rviz, robot-generic libraries, 2D/3D simulators, navigation and 2D/3D perception

wstool init -j8 src http://packages.ros.org/web/rosinstall/generate/raw/groovy/desktop-full

Desktop Install : ROS, rqt, rviz, and robot-generic libraries

wstool init -j8 src http://packages.ros.org/web/rosinstall/generate/raw/groovy/desktop-full

ROS-Comm: (Bare Bones) ROS package, build, and communication libraries. No GUI tools.

wstool init src -j8 http://packages.ros.org/web/rosinstall/generate/raw/groovy/ros_comm

这个操作是下载catkin包的代码到~/ros_catkin_ws/src目录下，-j8是指并行下载8个包，在RK3066上是无压力的，如果是树莓派可能需要减少。

注意，在后面解决依赖关系和构建的时候很多包依赖的库可能会缺，你可以根据错误提示自行安装所缺的库。我在MK802 IIIS上只成功编译了ROS-Comm，Desktop编译失败了，而Desktop full在官网wiki中说还有问题：There are build errors in desktop-full (gazebo simulator) at the moment, so the desktop variant is suggested at this time. See: https://code.ros.org/trac/ros-pkg/ticket/5595。

还可以安装其它的包，如robot：

wstool init -j8 http://packages.ros.org/web/rosinstall/generate/dry/raw/groovy/robot

更多的可以在REP 131中查阅。

4.2.2 解决依赖关系

在构建包之前你必须确保你解决了所有的依赖关系

rosdep install --from-paths src --ignore-src --rosdistro groovy -y

--from-paths选项表示我们想要安装某个文件夹下的所有包，这里是src文件夹。--ignore-src选项表示rosdep不应该从包管理器安装任何src文件夹的包，因为我们现在做的就是构建它。--rosdistro选项之所以需要是因为我们没有设置好ROS的环境，所以我们必须指明我们构建的是ROS的哪个版本。最后，-y选项表示出现的提示选择都选择yes

另外如果你在安装某些包出现错误的情况下仍想安装其它所有可以安装的包，你可以使用-r选项，也就是rosdep install --from-paths src --ignore-src --rosdistro groovy -yr。

4.2.3 构建catkin工作空间

调用catkin_make_isolated:

./src/catkin/bin/catkin_make_isolated --install

默认安装在~/ros_catkin_ws/install_isolated下，如果要安装到其它地方，比如/opt/ros/groovy，可以使用--install-space /opt/ros/groovy

如果编译过程中出现错误提示缺少库，需要自行安装解决。

如果构建完成了，再执行：

source ~/ros_catkin_ws/install_isolated/setup.bash

如果你只需要ROS Common那么就结束了。可以测试一下在终端里输入roscore，我运行的时候报错了，后来注释掉了一个python文件里的几行就跑起来了，具体是哪个文件也忘了，根据报错的信息修改就可以了。

4.3 构建rosbuild包

只构建ROS Common（Bare Bones）是不需要这一步的，在上一步我也没有成功编译desktop，
如果你成功了可以继续下面的步骤：

4.3.1 创建rosbuild工作空间

mkdir ~/ros_wscd ~/ros_wsrosws init . ~/ros_catkin_ws/install_isolated

4.3.2 下载ROS Stacks

Desktop-Full Install: 2d/3d simulators, navigation, robot models and several tutorial stacks

rosws merge http://packages.ros.org/web/rosinstall/generate/dry/raw/groovy/desktop-full

Desktop Install: ROS, rqt, rviz, and robot-generic libraries

rosws merge http://packages.ros.org/web/rosinstall/generate/dry/raw/groovy/desktop

Desktop-Full仍然有问题：There are build errors in desktop-full (gazebo simulator) at the moment, so the desktop variant is suggested at this time. See: https://code.ros.org/trac/ros-pkg/ticket/5595

rosws update -j8

4.3.3 构建ROS Stacks

下载完后：

source ~/ros_ws/setup.bashrosmake -a

5. 其它

如果你不满足于ROS Common，而且跟我一样没有成功编译desktop的话，可以试试单独编译其它组件，比如OpenCV和PCL。

OpenCV 2.4.3的编译非常顺利，几乎没有遇到什么障碍，有GTK+2.0，highgui库都可以正常使用。

PCL在我去掉少数几个编译选项以后也成功了，pcl_viewer正常工作。//另外我还安装了OpenNI和Kinect驱动

我编译PCL时的CMakeCache.txt在https://gist.github.com/4689753

参考资料

1. http://en.wikipedia.org/wiki/ROS_(Robot_Operating_System)
2. http://www.ros.org/wiki/
3. R. Patrick Goebel,ROS By Example Volume 1
4. http://www.ros.org/news/2012/12/ros-groovy-galapagos-released.html
5. http://ros.org/wiki/groovy/Installation/Source
6. http://answers.ros.org/question/10716/ros-on-arm/
7. http://ros.org/wiki/groovy/Installation/Raspbian/Source

MK80X开机后一般有两种模式，正常模式和恢复(recovery)模式。所以我们如果需要Android/Linux双启动，就只需要在recovery里刷入linux的kernel，Android可以正常运行互不影响。当然你也可以直接刷入原来的kernel空间覆盖掉Android，但是这种方式并不推荐。官方的recovery似乎功能不多，只有作为u盘的功能。Bob’s Finless ROM是一个修改的ROM，包含了替换recovery等img文件的工具。如果你的设备是MK808/MK808B或者UG802，就可以试试对应的Finless ROM，暂时没有针对其它型号的版本（公元2013年1月28日）。如果其它型号刷入，由于硬件不是都相同，可能会有一些问题。

需要的工具有：

• 显示器
  有HDMI接口直接插上就可以了，如果是VGA或者DVI接口的可以使用转接线，淘宝上有HDMI转VGA带3.5mm音频输出的转接线
• RKAndroidTool v1.35
  在Bob’s Finless ROM的包里
• 一个大于4G的TF卡或U盘或移动硬盘
• Linux和Windows
  Windows用于刷入recovery，Linux用于格式化上面所说的TF卡或U盘，写入rootfs。这个要求似乎有点苛刻，但是你可以寻找Windows下用于Ext4文件系统格式化的工具，或者寻找Linux的刷入recovery的工具，但这可能更加麻烦。
• USB网卡
  如果你的设备不是UG802/MK808
• Kernel镜像
• Root file system(Picuntu-linuxroot-0.9-RC2.2.tgz)
  你也可以使用一个安装脚本来更方便地完成安装过程，但这里介绍最直接（或者麻烦？）的方式

都准备好了的话，开刷吧！

1. 刷入kernel镜像

• 把你的设备通过USB线与运行Windows的PC相连，注意不能用只用于供电的Micro USB口连接。

• 在Android中安装“终端模拟器”，打开终端模拟器输入su和reboot bootloader，设备会变成黑屏，Windows会检测到RK30的硬件。然后安装驱动，当然如果之前安装过就不需要。

• 打开RKAndroidTool,这时应该显示Found RKAndroid Mass Storage Usb，而不是No found RKAndroid rock usb，否则就是你的驱动没有安装好或者设备没有进入bootloader。

• 只选择在recovery空间刷入recovery镜像，几秒之后刷好，立刻自动重启。

• 如果你重启以后进入recovery发现一只躺着的带着红色三角形Android，那么可能是你的recovery没有刷对。 //可能的原因是recovery-from-boot.p这个万恶的文件存在于你的Android系统根目录下，自动恢复原recovery，把它删掉或者重命名

刷好以后你将看到Linux的控制台滚屏，然后就可以进行下一步了

2. 创建rootfs

可以使用4GB以上容量的TF卡、U盘甚至移动硬盘来完成这步。

• 在Linux上打开GParted，在存储设备上创建一个至少4GB的Ext4分区，卷标为linuxroot //对，kernel就是根据这个卷标来找文件系统的

• 切换到root用户，解压tar压缩包，使用copy -a拷贝解压的所有文件和文件夹到linuxroot分区。 //注意最好不要直接解压到linuxroot分区，以我的失败经验做反例，好几次解压以后用不了就是一些文件没有完整复制过去

如果进不了登录界面，可能就是一些文件没有完整复制过去，或者你没有切换到root用户，又或者是其它什么原因？比如我。

3. 配置

首先我是没有成功用Picuntu直接进到图形登录界面的，不知道是哪里出的问题，但是用Ctrl+Alt+F2打开的控制台是可用的，用户名ubuntu，密码ubuntu，root用户密码是12qwaszx，登录以后输入startxfce4可以正常进入图形界面，其它一切功能正常。

如果 你的显示器分辨率不够不支持1080p，那么最好用720p，在/etc/rc.local里取消

1
2

# fbset 1280x720-60-32 -a 
# fbset -rgba 8/16,8/8,8/0,8/24 -a

这两行前面的’#’注释即可。

如果 你使用的是USB无线网卡，那么你的设备名应该是wlan1,首先sudo ifconfig wlan1 up,然后ifconfig应该能看到你的无线网卡，默认的/etc/network/interfaces是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 # interfaces(5) file used by ifup(8) and ifdown(8)
auto lo
iface lo inet loopback






auto usbnet0
iface usbnet0 inet dhcp


auto wlan0
iface wlan0 inet dhcp
      wpa-ssid Alok_Yamuna
      wpa-psk abcdefgh

你需要改成

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

 # interfaces(5) file used by ifup(8) and ifdown(8)
auto lo
iface lo inet loopback






auto usbnet0
iface usbnet0 inet dhcp


auto wlan1
iface wlan1 inet dhcp
      wpa-ssid your-ssid
      wpa-psk your-passwd

连上网络之后一切都好办了，各种apt-get。。。

如果 你的机器刷坏了，我。。。不负责。。。

参考资料

1. https://code.google.com/p/rk3066-linux/
2. http://www.slatedroid.com/topic/41654-pre-alpha-03-ubuntu-linux-for-mk802-iii-ug802-mk808-ug007-imito-mx1/
3. http://www.slatedroid.com/topic/46881-picuntu-09-rc-22-bug-fix-version-arrives/
4. http://ubuntu.g8.net/

“少即是多”，正因为它小，靠外部供电而非电池，有很多扩展的可能性，上市以后很火。到现在淘宝一搜MK802，会出现各种各样厂商（比如酷优乐，联力胜）的也叫做MK802或者UG802,MK803,MK808,MK809的之类的产品。可以给它刷上Linux，然后把它当成一个普通PC使用（因为驱动的原因，用自带的Android可能是更好的选择）。或者，不接显示器，做一个Headless Server？接移动硬盘做一个BT下载机？又或者，加上Arduino，连接上各种传感器，作为机器人的主控制器？总之可以做到很多平板做不到的事情。这里有一个简易对照表。

MK802的第一代产品是使用全志A10芯片的，在半年后看来这个芯片性能不够强了，运行桌面Ubuntu不是很流畅，但是它的Android ROM和Linux的支持已经比较完善了。后面有一个MK802 II是它的升级版，改动不大，系统基本也可以通用。

接下来出现了一个UG802,它不是由原来MK802的厂商瑞科美生产的，而是一个叫做酷优乐的公司。在搜索引擎上搜索“酷优乐”这个词都搜不到这个公司的网站。我是问淘宝客服才知道这个公司的网站的（kuyoule.cn），它是第一个使用RK3066芯片（1.66GHz,双核A9）的Mini PC。然后又出现了一个MK808（不知道是哪个产商的）ROM提升到8G，后来的MK808B增加了蓝牙，改进了WiFi天线（原来的好像WiFi信号不太好）。然后瑞科美才推出MK802 III，同样是使用RK3066芯片，不过个人感觉可能质量和ROM支持好一些。然后就是去年12月份推出的MK802 IIIS了，我买的就是这个。

RK3066的linux源码从一个西班牙的公司释出，然后AndrewDB开始开发，成功跑上了Ubuntu 12.10。

AndrewDB开发了一段时间，放出了kernel镜像和rootfs，最后的版本是Pre-Alpha 0.3,在MK802 III/UG802/MK808/UG007/iMito MX1等RK3066芯片的设备上都测试正常。然后他放出了一个Roadmap，就在论坛里神秘消失了==，再也没有出现。。。大神们都是神龙见首不见尾么。。。

AndrewDB在Google Code上创建了一个叫做rk3066-linux的项目,现在主要由AlokSinha2001接手了。他用MK808做了一个服务器，现在已经持续运行一个月了。1月15号正式发布了PicUntu，主要对服务器的用途做了一些改进，做了一个安装脚本还有一个apk的安装导引。目前（2013年1月24日）最新的版本是0.9 RC 2.2，google code不让放那么大的文件下载，于是直接转到了那个用MK808做的网站上提供下载。

运行起来还算流畅，使用Chromium没有什么问题，用ports.ubuntu.com的软件源安装软件也很方便，只是速度有点慢(似乎没有其它镜像？)。Mali 400的驱动有人正在尝试中…

Picuntu的安装在下一篇文章里介绍。

2012年8月，W、T、F三人陆续回到学校。

因为共同的机器人之梦，这个团队在今年5月份组建。

首先W同学有了一个想法，觉得可以把ARM11放在小车上，做一些图像处理的工作，然后再连上Arduino控制器控制小车运动，另外用一台Android手机来操控。

开始考虑用纯Linux加上Qt作为图形界面，用上OpenCV来做。事实上W同学之前因为做过类似的东西对这个已经比较熟悉了。只是由于摄像头驱动以及USB接口只支持1.1的原因，采集摄像头图像的速度非常慢，慢到无法忍受。

但是经过多次尝试，发现一款USB摄像头在ARM板厂商的测试程序当中速度很快，效果很理想，问题是厂商并没有开源这个摄像头测试程序的代码，如果要自己做驱动的话就不是一时半会能搞定的了。于是W同学又尝试了把板子刷上Android操作系统，由于有API可以调用，尽管这个程序闭源仍然可以使用。

于是W同学又从C/C++版本的OpenCV转到Android版本的OpenCV，在Android测试了一下自带的示例程序，发现会花屏。尝试了很多方法都未能解决。后来ARM板的损坏也导致不得不思考新的方案。

于是就到了8月份。

F同学由于要做Android客户端程序学习了Android编程。于是想到直接用Android手机代替ARM11开发板，这样会省去很多麻烦。而在这时，Android手机之间的单向socket通信已经基本完成，在解决了一些小问题以后工作很稳定，速度也很快。

很快，由于F同学曾经有做小车的经验，以及Arduino编程的经验，由Arduino控制的小车耗不费力地就跑了起来。
接下来遇到的第一个难题是Arduino与Android的通信。开始买Arduino的时候没有考虑这个问题，但现在需要与Android手机通信，主要有两个办法，蓝牙和USB，我们觉得蓝牙这个东西开关比较麻烦，也可能不够稳定，于是决定直接用USB Accessory，该特性由Android 2.3.4（平板是3.1）以上支持。开始看到很多论坛的帖子说华为中兴的手机不支持，真心捏了一把汗，还好后来证明三个人的手机都是可用的。

要解决这个问题，F同学查找了很多资料，最终终于完成了Android手机（客户端）传递信息到另一台Android手机（服务器），再由这台服务器传递信息到Arduino控制小车运动。反应很灵敏，效果很不错，非常好的一个玩具遥控车。

这个时候，bug只是偶尔出现，解决了以后基本就很完美了，工作都非常稳定。

可是一切才刚刚开始。

9月份，W研究了众多可用于Android平台上的计算机视觉库，包括OpenCV，SimpleCV，JavaCV以后，最终发现还是OpenCV比较适合，但是由于JNI接口使用觉得过于复杂，没有深入研究下去。于是利用Android上的OpenCV实现了追踪有明显颜色特征的物体（ColorBlob Track）并且绘制出其中心坐标。

在T同学完成数模一段时间之后，小车的Arduino部分主要转给他负责。买好了舵机，却发现转起来吱吱地响。让舵机云台根据前面所说的图像处理得到的点的位置跟踪目标，经过一个下午调整终于调好了，可舵机已经坏得差不多了，声音很吓人。后来拆开发现里面的齿轮是塑料的！顿时觉得被坑了，180多买来的二自由度舵机云台居然如此劣质！淘宝立刻给差评！后来买了两个20多块的MG995,质量都很好一直用到现在。

当然这还远远不是结束。接下来我们陆续实现了：

1. TTS

2. 小范围英文离线语音识别

3. Socket双向通信

4. 各种代码的分离和整合

F同学开始研究利用Android服务器上的陀螺仪计算角度和客户端的地图绘制。

借了一个平板过来。。。

然后，设计利用超声波测距检测拐角和使用QR码作为人工路标的导航机制：

此图好象是刚刚调通超声波模块，但却不知这是暴风雨前的宁静。

本以为超声波传感器+Arduino就一切OK了的，可后来发现事情远没有这么简单，因为Arduino Romeo的资源不足，开始认为是定时器不足导致超声波测距和USB Accessory无法使用。可后来尝试了各种方法，这个问题变得越纠结。

我们于是增加了一个MSP430作为辅助板来控制超声波传感器。调了很多天之后发现还是不可行，最终发现I/O口不足。

于是我们换用Google ADK。

可谁知道我们第一次买来的竟然是假货，用了不到24个小时就坏了，后来淘宝退货，立刻买下了另一个原装进口的。这一耽误又是好多天，这个时候星火杯如果按照原计划已经快开始了。

真假ADK：

在光棍节那天，我们终于完成了超声波和USB Accessory的共同测试！

经历了设备大换血之后，下面的一段时间，我们一直在做小车的导航。每天至少几十次的测试。小车跑过了好几百次了吧。还好星火杯也延迟又延迟，否则我们无法有很多时间来改进。

在前几天，Arduino与Android双向通信问题才完美解决，舵机转动影响陀螺仪的角度问题也基本解决。但在地图绘制方面还有一些不稳定。追踪小球上根据偏离中心距离调整速度，效果好了不少。

最后来一张Rosmin的笑脸：

哈哈，还有牺牲了一个手机壳有时还不得不举着舵机讲电话的T同学。。。

一切还只是刚刚开始

The Next is Rossum.

去年在什么都不懂的情况下移植的时候也主要是靠这篇文章，写得很详细，如果你觉得还不够详细的话，推荐个带图的:
opencv2.3.1在arm端的移植

这篇写得也不错:
Linux下移植OpenCV+Qt到ARM(Tiny6410)总结

我的环境是Ubuntu12.04,板子是友善之臂的tiny6410。

首先当然是装好arm-linux-gcc,配置环境变量，输入arm-linux-gcc -v有输出，这步就完成了。
然后是cmake,比较方便的是用带界面的cmake-gui,要注意的地方是CMAKE_INSTALL_PREFIX和WITH_TIFF还有CMAKE_EXE_LINKER_FLAGS。

第一个参数需要注意是因为我们编译的库是适用于ARM的，不应该直接放在/usr/local里，否则如果装了x86的OpenCV会有冲突，比如改成/usr/local/opencv-arm。第二个参数一般情况下需要去掉勾，因为似乎默认情况下ubuntu是没有这个支持的，要选上得自己装些什么东西。第三个参数是因为OpenCV需要这两个库的支持？我现在也还不太明白，总之加上-lrt和-lpthread就不会报错了。其它参数保持原状基本都不会报错。

cmake好后下一步是make,对于双核的机器加上-j4参数速度会快很多，但是也发烫，在系统监视器里看到四个线程的CPU都是接近100%,风扇一直呼呼地响。

然后是配置编译环境了，好像在2.3以后OpenCV的x86版安装好后都会有pkgconfig的.pc文件。//2.3以前的版本不清楚

所以比较方便的就是用pkgconfig来配置了，它的.pc文件是在/usr/local/lib/pkgconfig下面。这是适用于PC版本的OpenCV的（因为之前已经安装好了x86的OpenCV）。但是只要把那第一行的prefix路径改成ARM版OpenCV的安装路径（也就是上面CMAKE_INSTALL_PREFIX参数的值）就可以直接用了。opencv2.3.1在arm端的移植这篇帖子说再Libs里要加上-lrt -lpthread参数，我的环境下似乎不需要，但是加上也没什么问题。

这样配置好后，arm-linux-gcc编译的时候加上参数`pkg-config —cflags —libs opencv-arm`就行了,比如arm-linux-gcc `pkg-config —cflags —libs opencv-arm` test.c -o test。//在这个情况下.pc文件名是opencv-arm，注意是两个反引号。
我用的主要是Qt，所以在.pro文件里加上：

    unix {        CONFIG += link_pkgconfig        PKGCONFIG += /usr/local/lib/pkgconfig/opencv-arm.pc    }

但是编译成功后可能会显示一些警告，比如：

    ../../lib/libopencv_core.so, needed by /usr/local/opencv-arm/lib/libopencv_highgui.so, not found (try using -rpath or -rpath-link)

这个警告在我的情况下只要把opencv-arm/lib里的.so文件全部放到/opt/FriendlyARM/toolschain/4.5.1/arm-none-linux-gnueabi/sys-root/lib下面就可以解决，但事实上不管这条警告也不会出什么问题，不会影响到程序的运行。//去年移植的时候就一直没管

但是耗费我四天的根本就不是这些问题有木有啊！我要开始吐槽了有木有啊！

首先要吐槽一下u盘，有个以前编译好的程序放在u盘上一直不能运行，报错

    ../../lib/libopencv_core.so, needed by /usr/local/opencv-arm/lib/libopencv_highgui.so, not found (try using -rpath or -rpath-link)

和编译时那个警告一样，害得我以为是那个警告必须解决掉。后来折腾了好久发现只要把程序拷到板子的存储介质上就直接能运行了！尼玛啊是文件系统还是权限的神马问题啊！于是我就换成用nfs挂载了。

现在去年编译的那个程序是能运行了，可是新编译的程序都不能和OpenCV库连上，也是报相同的错，好吧，我试过把.so文件放在/lib下，放在/usr/local/opencv-arm/lib下，两个都放，甚至还试过新建好多个文件夹，放在/opt/FriendlyARM/toolschain/4.5.1/arm-none-linux-gnueabi/sys-root/lib下，结果都一样！只有老的程序能运行，新编译的都不行。后来脑袋终于开窍了，既然老程序可以运行，说明我移植的OpenCV库没有问题。于是我尝试直接用armm-linux-gcc编译了一个简单的程序，发现运行正常？！然后不知什么想法让我把新编译的程序拷贝到/mnt下，也就是nfs挂载的那个目录，神奇的事情发生了，它正常运行了！！！

那么，这究竟是什么原理呢？我到现在还没搞明白。nfs挂载以后，所有挂载的文件都相当于自己原本文件系统里的文件么？还是有权限什么的问题呢？

地址是http://210.27.10.208/,仅供西电校内访问。

现在校内外均可访问http://f120.tk/，ftp服务只有校内可以访问。

这可折腾了好久时间。我想我把路由器，网关之类的概念算是理解透了。

碰到各种各样的问题，linux的用户权限，防火墙，端口映射，配置文件…

还好最后都一一解决了。

采用wordpress做模板，用了v2press主题，于是它就变身论坛。

我是按这个帖子来操作的，把u盘分成两个区，一个ext3格式（据说比较稳定？），一个ext4格式。按照帖子成功挂载以后点开luci的System里的Software，发现空间已经是u盘那个指定分区的空间了，啊哈，想装啥就装啥。

接下来就是摄像头了。由于路由器只有一个usb口，所以得用hub。（废话）

我看到了这个帖子,软件源是不用改的，所以直接：

opkg updateopkg install usbutils

由于我的摄像头是杂牌的，芯片貌似不是301的，所以这跟多数人用的301方案不同。

首先在win7的设备管理器查到了我的摄像头的设备信息，搜到了型号。发现和帖子里的芯片型号一样，大喜呀。

然后我装了kmod-video-gspca-zc3xx（可能不用装的）和kmod-video-uvc。

结果竟然很快成功了。

接下来是：

opkg install mjpg-streamer

是’-‘不是’_’，和帖子里的不一样，因为跟那个帖子的软件源不同。

然后仍然按那个帖子把网页文件上传上去，输入命令：

mjpg_streamer -i "input_uvc.so -y -d /dev/video0" -o "output_http.so -p 8080 -w /www/camwww"

就可以在 http://192.168.0.1:8080/?action=stream 看到视频了。

我把画质调到了30,显示速度还可以。

关于输入配置参数：

-y 是关键，默认启动是mjpeg格式，这个就报错。改成YUV格式-d 指定设备-f 制定帧数，默认30帧-r 指定视频大小，如320×240-q 指定画质，默认80

关于输出参数：

-p 指定端口，这里是8080-w 指定网页目录，这里我们设置的是/www/camwww目录-c 设置通过密码访问

（注：眼下正值考试之际，无力详细写此教程，关于建立两个wifi，一个连接可以上网的wifi热点，一个作为接入点的部分没写，就忽略了吧。）

我用的书是《C++ GUI Qt 4 编程（第二版）》(C++ GUI Programming with Qt4,Second Edition)。书上给我的第一个有主窗口的完整应用程序的例子是一个电子表格程序，那叫一个复杂啊…虽然说基本把QT库的基本内容展现出来了，可是我实在消化不了那么多东西，而且涉及到表格，太过具体，这些比较细节的东西以后未必用的上。

所以我不打算完整的学下来，转而做一个简单的记事本程序。

这个程序有基本的标题栏，菜单栏，状态栏…

只是工具栏被我删掉了，感觉跟菜单栏比较类似，也懒得去做图标…

我找了一下网上的教程，有直接用Qt Designer图形界面操作的，但太傻瓜化，有些功能还实现不了。还有就是书上的例子，纯代码…而我是要做一个有基本界面还可以打开和保存文件，有剪切复制粘贴功能的记事本，用Qt Designer设计UI，然后再写一些代码。

所以参考了一个QT官网上的一个教程和书里的制作电子表格的示例程序，做了一个Quick and Dirty的记事本程序。

之所以Dirty，是因为它甚至还不支持中文！（勿喷，勿喷，写入文件是用一个叫做QTextStream的类弄的，我什么都不知道…）

同是C++初学者的我，压根搞不清状况。那么多乱七八糟的类和对象。问题是Qt Designer设计的ui对象我搞不懂怎么用代码操作，书上它是纯代码的也没讲。

后来还是QtCreator这个给力的IDE好使啊，打出ui，再按点号，自动将点号转成”->”，然后用特殊方式显示“ui”，这是说，它找到了这个对象，原来这个对象就叫ui…查了一下前面的定义，大体上看懂了。。。

把窗体初始化以后，然后就是各种信号和槽的连接…各种QT的类，揣摩各种语法规则(本人比较懒，不想查书…)，Google各种error…在这个过程中，总算是了解了基本的QT编程。

最开心的事情：setShortcut(QKeySequence::XXX)是在各种操作系统上的万能钥匙啊，什么快捷键，系统给你，不用写，哈哈～

代码在https://github.com/sun11/QTGUI_Writer