这篇文章主要针对linux纯命令行环境下安装windows的需求。

1. 安装Virtualbox

• 下载
• rpm

2. 安装扩展工具包

• vboxmanage extpack install Oracle_VM_VirtualBox_Extension_Pack-5.1.22-115126.vbox-extpack

3. 创建虚拟机

• VBoxManage createvm --name "Windows XP" --ostype WindowsXP --register

4. 配置虚拟机，以下命令也可以合并到一行完成

• vboxmanage modifyvm win2003 --ostype Windows10 配置系统类型,如果不是win10 32位可以通过vboxmanage list ostypes查找下
• vboxmanage modifyvm win10 --memory 2048 配置内存2G
• vboxmanage modifyvm win10 --acpi on 配置电源管理
• vboxmanage modifyvm win10 --nic1 nat 配置网卡工作模式
• vboxmanage modifyvm win10 --cpus 2 配置CPU数量

5. 创建虚拟硬盘

• vboxmanage createhd --filename win10.vdi --size 102400 新建一个100G的硬盘，注意这里会在当前目录下创建，如果需要管理的话记得换个目录。
• vboxmanage storagectl win10 --name win10HDD --add ide --bootable on 新建硬盘控制器
• vboxmanage storageattach win10 --storagectl win10HDD --port 0 --device 0 --type hdd --medium win10.vdi 绑定硬盘

6. 安装系统

• vboxmanage storageattach win10--storagectl win10HDD --port 0 --device 1 --type dvddrive --medium win10.iso 挂载镜像
• VBoxManage modifyvm win10 --vrde on 打开VirtualBox remote desktop extension（不然无法远程装系统）
• VBoxHeadless --startvm win10 打开虚拟机并开始安装程序

7. 后续工作(在刚才的远程桌面中配置并打开运行远程连接后)

• vboxmanage modifyvm win10 --natpf1 "remote desktop,tcp,,3390,,3389" 增加名称为“remote desktop”的端口转发，可以通过VBoxManage modifyvm win10 --natpf1 delete "remote desktop"删除
• firewalld-cmd --add-port=3390/tcp --permanent 打开防火墙3390端口（如用iptables自行修改）
• VBoxManage modifyvm win10 --vrde off 关掉virtualbox的远程桌面
• vboxmanage startvm win2003 --type headless 从后台启动虚拟机（不然命令行窗口关了虚拟机就停了）

TIPS:

1. 备份虚拟机

• vboxmanage clonevm win10-Base --name win10-Test --register

2. 取消注册虚拟机

• vboxmanage unregistervm win10-Base

在开发一个游戏插件时，有些东西是可以共用的，有些东西则是每个游戏单独有的。如何将这些内容区别开来，将共用的抽象成库，有助于提高以后的开发速度

可以共用的部分

1. 一套更加完善的命令处理机制

• bukkit自带的命令处理机制并不完美，需要写很多重复的代码，比如判断命令发送者的权限，是否是玩家等等，通过写一个代理来执行可以有效降低代码量。
• 在上一步的思路上，设计一套Annotation接口，把每个命令的要求通过Annotation配置，效率可以大大提升。

2. 游戏初始化的逻辑

• 玩家排队的相关逻辑，如按顺序进入游戏、延迟传送等
• 一些游戏启动，监听加载的逻辑

3. 游戏状态的控制

• 一个游戏从启动到结束的生命周期是类似的，由系统托管生命周期也有助于减少工作量

不可以共用的部分

1. 每个游戏的逻辑

• 虽然很多游戏有相似之处，如：跑酷类型的游戏都是又一个点跑到另一个点，但是提取这种共用逻辑的价值不大，基本上没有重复使用的价值。除非是小游戏集合，有很多相似的游戏在一个包里面。
• 这个与游戏初始化的区别是，游戏初始化时每个小游戏必须要有的，但是这部分不一定。

2. 监听操作

• 虽然很多监听操作是可以共用的，但是这样无疑会导致监听代码的复杂度直线上升。每个小游戏单独有自己的监听逻辑，启动时开启监听，结束时关闭监听。不仅有助于使代码更简洁，也能有效提高程序效率。

在下一些国外的库时，如果直接下的话会非常慢，这个时候就需要为Maven配置一下代理~

打开File->settting，然后搜索Maven，打开Maven下的Importing选项，在VM Options for importer一栏后面加上 -DproxySet=true -DproxyHost=localhost -DproxyPort=1080。

这里面localhost就是代理服务器地址，1080就是端口。

由于Spigot插件在不断更新，很多已有的中文文档已经不再适用，因此编写这篇文档对Spigot的官方教程做整理和翻译。
这份文档是为具备Java基础的开发者准备的，一些关于项目创建的过程直接略过了，只整理开发插件的核心内容。

新建项目

1. 新建一个Java或Maven项目
2. 导入spigot-api和bukkit的jar包

• 这里可以在https://hub.spigotmc.org/nexus/#welcome中搜索spigot-api和bukkit，下载自己所开发版本对应的包，下载并拖到项目依赖中。
• 如果不想手动下载，可建一个Maven项目，加入下面的repositories依赖，再把搜索结果右下方的信息复制到Maven的配置文件中，更新一下即可。

<repositories>
    <repository>
        <id>spigot-repo</id>
        <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
    </repository>
</repositories>

创建插件

1. 新建插件的主类

• 插件的主类需要继承JavaPlugin
• JavaPlugin 提供了插件工作时所需要的各种方法和属性
• 每个插件只能有一个主类，其它需要JavaPlugin的地方可以在onEnable()中将属性的引用传递过去。

2. 重写onEnable()和onDisable()方法

• 这两个方法会在服务器启动和关闭插件时执行

3. 编写plugin.yml

• 这个文件描述了插件的相关信息，其详细格式可参考下面代码

Main.java

package org.spigotmc.tutorial;

import org.bukkit.plugin.java.JavaPlugin;

public class Main extends JavaPlugin {
       @Override
       public void onEnable() {

       }

      @Override
      public void onDisable(){

      }
}

plugin.yml

name: //插件的名称
version: //插件的版本
author: //插件的作者
main: //插件的主类，记得带包名
depend: //插件的前置依赖
website: //作者网站，通过 /version <pluginname> 可以查看
commands: //插件的命令（没有可以不写）
      <command>:  //命令名称，不带'/'
               description: //命令描述，/help 时可以查看
               usage: //命令在控制台中的使用方式，带'/'

创建一个命令

1. 新建命令类

• 命令的主类需要引用CommandExecutor 接口

2. 重写public boolean onCommand(CommandSender commandSender, Command command, String label, String[] args)方法

• commandSender - 命令的发送者，可以是玩家、控制台或命令方块
• command - 发送命令的一些信息，其实就是plugin中配置的一些信息，感觉这个参数没啥作用呀
• label - 玩家敲的命令，会自动去掉'/'，感觉这个参数也没啥用
• args - 玩家敲的命令后面跟的参数

3. 在主类中注册命令类this.getCommand("kit").setExecutor(new CommandKit());

• getCommand中的值在plugin.yml中需要有对应，否则会返回null

4. 在plugin.yml中添加这个命令即可
5. 补充：如果指令发送者为玩家，就可以通过(Player) commandSender强制转换获得玩家对象

• 记得先判断一下，防止代码出错if (sender instanceof Player)

CommandKit .java

public class CommandKit implements CommandExecutor {
    // This method is called, when somebody uses our command
    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
        if (sender instanceof Player) {
            Player player = (Player) sender;

            // Create a new ItemStack (type: diamond)
            ItemStack diamond = new ItemStack(Material.DIAMOND);

            // Create a new ItemStack (type: brick)
            ItemStack bricks = new ItemStack(Material.BRICK);

            // Set the amount of the ItemStack
            bricks.setAmount(20);

            // Give the player our items (comma-seperated list of all ItemStack)
            player.getInventory().addItem(bricks, diamond);
        }

        // If the player (or console) uses our command correct, we can return true
        return true;
    }
}

Main.java

@Override
public void onEnable() {
        // Register our command "kit" (set an instance of your command class as executor)
        this.getCommand("kit").setExecutor(new CommandKit());
    }

plugin.yml

# Replace "kit" with the name of your command.
commands:
  kit:
    description: Your description
    usage: /kit

创建一个事件监听

1. 新建监听类

• 监听类需要实现Listener接口

2. 添加需要监听的方法

• 方法名称为 public void on+事件名称(事件名称 event)
• 事件名称可以在javadoc中org.bukkit.event包下面查找
• 比如有个玩家加入的事件PlayerJoinEvent，那么就写public void onPlayerJoin(PlayerJoinEvent event)
• 记得加上@EventHandler注解
• event的方法在javadoc里面也可以查得到

3. 在主类中注册监听类getServer().getPluginManager().registerEvents(new MyListener(), this);

MyListener.java

import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;

public class MyListener implements Listener
{
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event)
     {
         event.setJoinMessage("Welcome, " + event.getPlayer().getName() + "!");
     }
}

Main.java

@Override
public void onEnable()
{
    getServer().getPluginManager().registerEvents(new MyListener(), this);
}

数据统计

数据统计工作是为了获得行人位置的分布区间。统计方法为计算不同高度下的行人ROI上边界和下边界距离假设的水平线的距离。

通过在DetectModule输出结果的部分插入以下代码实现统计：

if (roi->height < 200)
{
	count[1][roi->height >> 2] += (240 - roi->y - DST_START_COL); //此处统计上边界距离水平线距离
	count[0][roi->height >> 2]++;

	for (int i = 0; i < 50; i++)
	{
		printf("%.2f ", count[0][i] == 0 ? 0 : count[1][i] / count[0][i]);
	}

	printf("\r\n");
}

统计结果按高度每4个像素为一个阶梯，分布如下图。

接下来统计一下分布距离与ROI高度的关系

从统计结果可以看书，上下边界距离水平线的距离大约呈线性增加，平均比率分别为0.6和0.4。

接下来针对70米(30~50个像素高度)左右距离的ROI进行分析，判断在某个距离下的ROI分布:

if (roi->height > 30 && roi->height < 40)
{
	int t = (240 - roi->y - DST_START_COL + 10);
	if (t > 0 && t < 50)
	{
		count[0][t]++;
	}
	
	for (int i = 0; i < 50; i++)
	{
		printf("%d ", count[0][i]);
	}

	printf("\r\n");

	//printf("%d - %d\r\n", roi->y + DST_START_COL, roi->height + roi->y + DST_START_COL - 240);
}

得到下图：

通过该图可以看出，70米左右距离的行人ROI距离水平线距离呈正太分布，平均值在13。最边界的ROI可能由于误检或车抖动造成漂移较大。

在行人识别的最后步骤，需要对识别出的行人进行标记。通常在实验阶段往往只是把ROI的框涂出来，但是在工程阶段，需要更加精细的标记方法以获得更好的用户体验。

经过总结，标记的ROI需要满足以下需求：

• 只标记人的身体部分，不填或少填无关的部分；
• 标记部分显示黄色，颜色深浅随着roi的置信度变化；

设计思路：

• 一般人体的亮度均大于背景，因此可以设置一个阈值，只标记高于阈值的像素，实现只标记人体部分。
• 我们红外图像只有亮度信息，对应到RGB色域中，RGB的值就是亮度的值。因此我们可以调高R和G的值来提高黄色的色度，降低B的值来增加颜色的深度。只要R和G的值一样且大于B就能获得理想的效果。

那么开始设计：

1. 去除背景部分

• 经过测试，行人身体的亮度大都大于192，因此只标记亮度大于192的像素。

2. 通过两个像素的均值确定需要填图的黄色色度

• yy = (ptr[current + 1] + ptr[current + 3]) >> 1;

3. 根据当前亮度，调整黄色的明暗程度，这部分yb的值必须小于yy

• yb = yy - (1 << level);

4. 计算具体的亮度值

• 因为R和G固定，因此直接优化为0.886 * yy，再带入上一公式，化简
• y = yy - 0.114 * (1 << level);

5. 换算YCbCr

• ptr[current + 1] = y;
• ptr[current + 3] = y;
• ptr[current] = (yb - y) * 0.564 + 128;
• ptr[current + 2] = (yy - y) * 0.713 + 128;

6. 化简

y = ((ptr[current + 1] + ptr[current + 3]) >> 1) - 0.114 * (1 << level);

ptr[current + 1] = y;
ptr[current + 3] = y;
ptr[current] = (0 - 0.886 * (1 << level)) * 0.564 + 128;
ptr[current + 2] = (0.114 * (1 << level)) * 0.713 + 128;

效果展示

模块化设计

行人识别算法的具有一定的复杂度，在设计系统框架时要处理好以下问题：

• 单一职责原则
• 里氏替换原则
• 依赖倒置原则
• 接口隔离原则
• 迪米特法则
• 开闭原则

单一职责原则

**定义：**不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。

**实现：**对系统功能模块化，每个模块只负责自己的功能。

里氏替换原则

**定义：**如果对每一个类型为 T1的对象 o1，都有类型为 T2 的对象o2，使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化。

**实现：**定义存储函数接口的结构体，在结构体中定义函数接口。不同的模块提供一个构造函数，在构造函数中申明接口实现并返回该结构体。针对不同的实现只需要将结构体中的函数接口指向不同的实现，上层模块的调用不会有感知。

依赖倒置原则

**定义：**高层模块不应该依赖低层模块，且都应该依赖其抽象。

**实现：**高层模块定义接口，底层模块按照接口设计其实现。高层模块通过对象工厂拿到底层模块的实例，不需要依赖底层模块的头文件。

接口隔离原则

**定义：**客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

**实现：**采用多层模块的方式，对内允许模块定义自己的子模块，对外定义统一的操作接口，最小化模块的任务。

迪米特法则

**定义：**一个对象应该对其他对象保持最少的了解。

**实现：**在设计检测引擎的时候，引擎只关注于其定义好的四个子模块，不关心子模块的内部实现。子模块在自己的构造函数中完整自己的初始化。

开闭原则

**定义：**一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

**实现：**在ROI模块中，为避免其他模块存储数据依赖ROI的问题，为ROI模块设计了存储注册机制。遵循先注册后存储的过程，避免对ROI模块的修改。

模块设计的过程

1. 解耦
2. 定义接口，标准化代码逻辑
3. 去除头文件依赖

总结分三大部分：html、css和javascript，每部分再分成两个子部分，分别是基础知识和记忆知识。

• 基础知识指前端开发必须会的东西，比如页面渲染方式、js基础语法等。
• 记忆知识指一些单纯背背就可以的知识，忘记的话可以查，但是免试官可能喜欢问（哭笑

Html相关

浏览器内核 [记忆知识]

浏览器内核又可以分为渲染引擎和js引擎两部分，后来js引擎越来越独立，内核也就更倾向于指渲染引擎本身的部分。目前常见的内核引擎有Trident、Gecko、Blink、Webkit四种。

• Trident

  • 微软开发的内核，从IE4一直用到现在IE11。因为有过一段时间比较牛逼，拖更了很久，导致其与W3C标准脱节，加上大量BUG和安全问题都没有解决，导致现在很多用户用IE是为了下载其它浏览器。现在Win10最新的Edge浏览器已经不用这个内核，而是用自己开发的edge内核。

• Gecko

  • 是一个开源内核，源自于古时候与ie对抗的Netscape。目前前端开发经常使用的Firefox浏览器就使用Gecko内核。另外这个内核还兼容很多平台，各种系统都能用。

• Webkit

  • 苹果公司开发的内核，早起也被chrome使用。后来因为chrome火了，导致大家以为webkit是谷歌弄得，哈哈。其前身是KDE的KHTML。

• Blink

  • 谷歌Chrome目前使用的内核，其前身是Chromium，而Chromium的前身就是webkit。因为商业竞争等各种关系，谷歌弄出了blink与苹果分道扬镳。

参考来源 ：

[1] 主流浏览器内核介绍（前端开发值得了解的浏览器内核历史）

DOM操作 [基础知识]

DOM的全称是Document Object Module, 文档对象模型，他是独立于语言而存在的。

• 根据 W3C 的 HTML DOM 标准，HTML 文档中的所有内容都是节点：

• 整个文档是一个文档节点

• 每个 HTML 元素是元素节点

• HTML 元素内的文本是文本节点

• 每个 HTML 属性是属性节点

• 注释是注释节点

• window.documnet是浏览器为我们提供的可以操作dom的接口。

• 随着Html5标准的推广，很多大家常用的JQuery的一些方法与浏览器原生提供的方法差别不大了，可以多了解一下原生的API。

参考来源 ：

[1] 原生JavaScript的DOM操作汇总

[2] 理解DOM结构

DOM渲染方式 [基础知识]

浏览器在读取Html文档后，首先会构建DOM树，随后构建渲染树，最后渲染并显示。

分词算法

算法的输出是HTML符号。算法可以用状态机来描述。 每一个状态从输入流中消费一个或多个字符，并根据它们更新下一状态。决策受当前符号状态和树的构建状态影响。这意味着同样的字符可能会产生不同的结果，取决于当前的状态。算法太复杂，我们用一个例子来看看它的原理。

基础示例，分析下面的标签:

<html>
	<body>
		Hello world
	</body>
</html>

初始状态是”Data state”，当遇到”<“时状态改为“Tag open state”。吃掉”a-z”字符组成的符号后产生了”Start tag token”，状态变更为“Tag name state”。我们一直保持此状态，直到遇到”>”。每个字符都被追加到新的符号名上。在我们的例子中，解出的符号就是”html”。

当碰到”>”时，当前符号完成，状态改回“Data state”。””标签将会以同样的方式处理。现在”html”与”body”标签都完成了，我们回到“Data state”状态。吃掉”H”（”Hello world”第一个字母）时会产生一个字符符号，直到碰到””的”<“符号，我们就完成了一个字符符号”Hello world”。

现在我们回到“Tag open state”状态。吃掉下一个输入”/”时会产生一个”end tag token”并变更为“Tag name state”状态。同样，此状态保持到我们碰到”>”时。这时新标签符号完成，我们又回到“Data state”。同样””也会被这样处理。

树的构建算法

当解析器被创建时，文档对象也被创建了。在树的构建过程中DOM树的根节点（Documen）将被修改，元素被添加到上面去。每个分词器完成的节点都会被树构建器处理。规范中定义了每一个符号与哪个DOM对象相关。除了把元素添加到DOM树外，它还会被添加到一个开放元素堆栈。这个堆栈用于纠正嵌套错误和标签未关闭错误。这个算法也用状态机描述，它的状态叫做”insertion modes”。

让我们看看下面输入的树构建过程：

<html>
	<body>
		Hello world
	</body>
</html>

树的构建过程中，输入就是分词过程中得到的符号序列。第一个模式叫“initial mode”。接收 html 符号后会变成“before html”模式并重新处理此模式中的符号。这会创建一个HTMLHtmlElement元素并追加到根文档节点。

然后状态改变为“before head”。我们收到”body”时，会隐式创建一个HTMLHeadElement，尽管我们没有这个标签，它也会被创建并添加到树中。

现在我们进入“in head”模式，然后是“after head”，Body会被重新处理，创建HTMLBodyElement元素并插入，然后进入“in body”模式。

字符符号”Hello world”收到后会创建一个”Text”节点，所有字符都被一一追加到上面。

收到body结束标签后进入 “after body” 模式，收到html结束标签后进入“after after body”模式。所有符号处理完后将终止解析。

参考来源 ：

[1] 浏览器是怎样工作的：渲染引擎，HTML解析（连载二）

CSS

CSS hack [基础知识]

css hack用于处理不同浏览器css样式不兼容的问题，但这种方法并不利于代码的维护，不到万不得已不建议使用。

• 条件注释法
  • 微软专属hack方式，也是官方推荐的方式。
• 类内属性前缀法
  • 通过加一些只有部分浏览器能识别的类前缀，需要查表选择前缀。
• 选择器前缀法
  • 在选择器前面加前缀，与上面类似。

参考来源 ：

[1] 史上最全的CSS hack方式一览

盒模型 [基础知识]

直接看图就ok啦

• 特别注意的是：ie低于版本8的浏览器的盒子模型中的width包括内边距和边框

参考来源 ：

[1] CSS 框模型概述

Javascript

数组的相关操作 [记忆知识]

1. concat()

• arr.concat(arr1, arr2, a1, a2)
• 在arr后面添加新的元素
• 返回新的数组，不修改调用的数组

2. join()

• arr.join(sparate)
• 使用将数组拼接成字符串，用sparate连接
• 返回拼接的字符串

3. pop()

• arr.pop()
• 删除数组最后一个元素
• 修改原数组，返回删除的元素

4. push()

• arr.push(a1,...,ax)
• 在数组最后面添加元素
• 修改原数组，返回新的长度

5. shift()

• arr.shift()
• 删除数组中第一个元素
• 修改原数组，返回删除的元素

6. unshift()

• arr.unshift(a1,...,ax)
• 在数组最开始添加元素
• 修改原数组，返回新的长度

7. reverse()

• arr.reverse()
• 颠倒数组中所有的元素
• 修改原数组，返回颠倒后的原数组

8. slice()

• arr.slice(start, end)
• 提取数组中start至end的元素
• 不修改原数组，返回新提取的数组

9. splice()

• arr.splice(index,count,a1,...,ax)
• 替换数组中指定范围的元素，还可以用于删除或插入操作
• 修改原数组，返回被删除的元素

10. sort()

• arr.sort(compareFunction)
• 对指定数组进行排序，如果没有指定比较方法，则将按字母顺序对数组中的元素进行排序
• 对原数组操作，返回排序后的原数组

11. filter()

• arr.filter(callback)
• callback : function(element, index, array)
• 返回一个新的符合callback测试为true的结果集，该方法可以用于遍历整个arr
• 不修改原数组，返回新的数组

12. map()

• arr.map(processFunction)
• callback : function(element, index, array)
• 返回一个新的由callback结果构成的数组，用于处理数组中所有元素
• 不修改原数组，返回新的数组

参考来源 ：

字符串所支持的正则表达式 [基础知识]

1. str.search()

2. str.match()

3. str.replace()

4. str.split()

[1] JavaScript Array 对象

Angular2的路由不像backbone是url#route这种结构，使用的是html5的pushstate方法直接从url中获得路由，这就需要进行一定配置才可以使angular2运行。

1. base href的配置

• 代码：<base href="/">
• base href的配置关系到路由的有效数据的选取
• base href同样关系到该网页的js、css等数据的获取，因此不能乱设定。

2. 后台的配置

• Angular2的路由方式使得用户刷新页面时，后台默认返回404错误。
• 需要在后台配置一下，当用户访问的路径为Angular2应用的路径时，返回Angular2首页的数据。（或者只要是匹配不到的路径，直接返回Angular2首页的数据）
• 注意是后台直接返回数据即可，不是重定向。

3. 子路由的配置

• Angular2的路由允许空component，一些目录可以不用配置component。
• 如果把APP的路由都放到某个子路径下面有助于简化后台重定向时的匹配复杂度。

4. 默认页面的处理

• 正常访问网址是默认地址是登录页面。
• 凡是带APP的子路径的地址，默认返回Angular2的数据，否则重定向到首页。

为了提高数据库的存储效率，需要为常用的检索字段添加索引，这里做一下整理：

创建索引

创建普通索引

db.collection.ensureIndex({"KEY":1})

这里就为collection中KEY字段添加了増序的索引，改成-1就是降序。

创建唯一索引

db.collection.ensureIndex({"KEY":1},{"unique":true})

这里增加了{"unique":true}，唯一性索引和mysql中的概念相同。

创建稀疏索引

db.collection.ensureIndex({"KEY":1},{"sparse":true})

因为mongodb不像mysql，有些文档可能缺失索引的字段，稀疏索引可以保证不含该字段的文档不会被检索。

查看索引

db.collection.getIndexes()

可以查看collection中的所有索引。

删除索引

db.collection.dropIndex("KEY")

可以删除KEY索引，如果dropIndex方法不传入参数，则删除所有索引。

在网络上运行的mongodb服务，用户配置是必不可少的，但是目前大部分配置用户角色的资料都比较旧，有些方法甚至已经被遗弃，因此这里做一下整理。

1. 配置管理员

• 确定数据库启动时没有添加-auth参数，启动数据库
• 在admin数据库下新建管理员用户

use admin
db.createUser(
  {
    user: "username",
    pwd: "password",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  }
)

这里userAdminAnyDatabase参数是申明用户管理员权限，也可以改成admin就拥有所有权限了。db参数不能少，否则会报错。

2. 启用mongodb的认证功能

• 添加-auth参数并重新启动数据库
• 在所需要管理的数据库下新建管理用户

use database

db.createUser(
 {
   user: "username",
   pwd: "password",
   roles: [
      { role: "readWrite", db: "database" }
   ]
 }
)

完成！！

DSP侧如何统计具体函数运行时间？

TI DSPC64x+内核有一个64位的硬件定时器（Time Stamp Counter），它的频率和CPU频率一致。
最简单的办法是使用TSC的低32位TSCL。注意在DM644x中，TSCH用于ARM。

#include void main (){
…
TSCL=0;
…
t1=TSCL;
my_code_to_benchmark();
t2=TSCL;
printf(“# cycles == %d\n”, (t2-t1));
}

来源：http://www.ti.com.cn/general/cn/docs/gencontent.tsp?contentId=61575

有时候出门在外，需要修改一个bug却苦于没有开发环境，一个远程的开发机的重要性便凸现出来。
传统的配置vncserver的方式需要安装大量的软件包，对于系统整洁强迫症来说便难以忍受。使用Docker的方式把整个环境打包，需要时启动，不需要时remove掉，不仅可以保持服务器干净整洁，还可以实现工作环境的快速迁移。

部署流程

• 寻找一个基础的vncserver的docker镜像，我这里在GitHub上找到一个不错的镜像：https://github.com/queeno/docker-ubuntu-desktop。它配置很简单，就是基于Ubuntu:16.04，安装tightvncserver和相关的软件包，然后把xstartup配置文件和passwd密码文件复制到镜像中（默认密码是password）。

FROM ubuntu:16.04

ENV DEBIAN_FRONTEND noninteractive
ENV USER root

RUN apt-get update && \
    apt-get install -y --no-install-recommends ubuntu-desktop && \
    apt-get install -y gnome-panel gnome-settings-daemon metacity nautilus gnome-terminal && \
    apt-get install -y tightvncserver && \
    mkdir /root/.vnc

ADD xstartup /root/.vnc/xstartup
ADD passwd /root/.vnc/passwd

RUN chmod 600 /root/.vnc/passwd

CMD /usr/bin/vncserver :1 -geometry 1280x800 -depth 24 && tail -f /root/.vnc/*:1.log

EXPOSE 5901

• 修改软件源：
  • 这个包使用的Ubuntu:16.04使用的是国外的软件源，导致build的速度非常慢，这里可以改成使用国内软件源的镜像，我这里做了一个

FROM akkz/docker-ubuntu-chinese-resources:release-14.04

• 增加中文的字体支持
  • 在RUN chmod 600 /root/.vnc/passwd后面加上

RUN apt-get install -y ttf-wqy-microhei && \
    apt-get install -y ttf-wqy-zenhei && \
    apt-get install -y xfonts-wqy

• 如果有需要，加上GBK支持的命令，格式和上面相同

• 加上工作所需要的软件的安装指令，如：

RUN apt-get install -y firefox

• 启动镜像

注意事项

• 有时候中文乱码可能因为字体没有装，不要陷在GBK的安装中。
• 用docker-compose可以提高部署效率
• 端口可以映射到其它端口，提高安全性

1. 软件架构设计

• 软件架构可以借鉴MVC的方式，View层负责页面跳转和事件监听，Controller层负责业务逻辑处理，Dao层负责数据发送和接收。

2. 页面跳转/刷新时事件的注册与取消注册

• 大部分页面需要根据后台数据生成html，这就用到了html的模板技术。当使用类似于template7这类模板引擎时，如何管理生成页面的事件就成为了一个问题。
• 目前我探索出来的方式是，使用jQuery的on方法，把事件挂载在当前页面的根节点上，这样不管页面内容如何刷新都不会影响到事件的监听。
• 貌似一些类似于backbone的前端框架可以帮忙解决事件的监听问题。

3. 与服务端数据交互时的问题

• Ajax刷新时需要给用户一个等待的反馈，请求结束后也需要给用户一个结果的反馈，由于不同模块反馈的内容不一样，因此如何实现一个公用的方案也需要考虑。
• 我的想法是，配置一个公用的存储反馈内容的json对象，调用dao层方法的时候把配置和该对象一起传进去，减少业务层逻辑的复杂程度。

4. id、class与css选择器使用的问题

• 有时候为了好看，在写css选择器的时候会写上一串限制的参数，如果对于一些经常复用的class这应该是个好方法，但是我发现用着用着就把class当id用了，很多定义的class只使用了一次。我觉得以后在开发前先大致设想好自己想使用的class，提取一些公用的内容，把这种方案的特点发挥到极致。
• 对于页面中绑定的事件等操作，可以不用写上一串选择器，因为绑定是运行时实时生效，不会因为页面切换导致绑定到其它class上面去了。

5. view层函数的结构

• 在写view层方法的时候，我习惯于写上init和load两个方法，其中init负责初始化事件监听，load负责加载和渲染页面，在实践后我觉得这是个非常实用的设计方案，但是目前我的代码仍然有很大的冗余，每个view都要写上init和load的调用。以后开发可以抽象出一个公用的view，然后调用loadView的方法传递一个json对象初始化view，json对象里面有init和load两个函数的定义，而对这两个方法的调用则由公共的view完成，减少代码冗余。

6. dao层函数的结构

• 在写dao层方法的时候，可以对jQuery的ajax的方法再进行一次封装，对错误的结果有个统一的处理方式。
• 在这一层的开发上，需要与后台接口协商好参数名和格式，如果出现相同参数多个名字（后台比较乱）的情况，最好还是加一层封装，预处理一下数据。假如后台返回的数据格式已经非常完善的话，那么直接回给controller层即可。

最近完成了DSP平台上行人识别程序的框架设计与实现，这里总结一下开发过程中遇到的问题及解决方案：

1. BIOS配置文件修改生效问题

CCS3.3编译程序的方式有increase build和build all两种方式，通常情况下如果只有改了某个文件，可以选择increase build来提高算法的编译速度。但是如果修改了配置文件，则一定要选择build all，否则修改无法生效。

2. 周期函数、软中断的配置问题

在BIOS中配置周期函数和软中断的时候，要注意中断配置的名称和它调用的方法不能同名，如果同名的话会导致配置失效。

3. 不同中断函数之间变量共享方式

多个中断函数需要共享某些变量时，可以使用闭包的方式，避免全局变量的使用。即将这几个函数定义在一个.c文件中，使用static修饰共享的变量。

4. 模块复用性提高

上面闭包的方式可以使多个软中断函数共享变量，但是这种设计会降低模块的复用程度，比如相同的检测模块调用多次完成对不同尺度下图像的检测。这时可以使用结构体存储模块的配置参数，每次调用模块中方法使将配置结构体传回，实现对模块的复用。

5. 对内部函数与变量的保护

为了防止外部调用不应该调用的函数，可以定义两个头文件，头文件1声明外部调用需要使用的结构体和函数，头文件2定义内部使用的函数，公开模块时只公开头文件1即可。