随便拍了两张图片作为测试图像。

下面上下两图分别为模板图像和查询图像：

提取左右图特征：

[cpp toolbar="true"]
Mat img1 = imread(image_filename1, 0);
Mat img2 = imread(image_filename2, 0);
//GaussianBlur(img1, img1, Size(5, 5), 0);
//GaussianBlur(img2, img2, Size(5, 5), 0);

ORB orb1(3000, ORB::CommonParams(1.2, 8));
ORB orb2(100, ORB::CommonParams(1.2, 1));

vector keys1, keys2;
Mat descriptors1, descriptors2;

orb1(img1, Mat(), keys1, descriptors1, false);
printf(“tem feat num: %d\n”, keys1.size());

int64 st, et;
st = cvGetTickCount();
orb2(img2, Mat(), keys2, descriptors2, false);
et = cvGetTickCount();
printf(“orb2 extraction time: %f\n”, (et-st)/(double)cvGetTickFrequency()/1000.);
printf(“query feat num: %d\n”, keys2.size());
[/cpp]

注：模板图像在多尺度提取特征，查询图像只在提取原始尺度上的特征。

做穷举式的最近邻检索：

[cpp toolbar="true"]
// find matches
vector matches;

st = cvGetTickCount();
//for(int i = 0; i < 10; i++){
naive_nn_search2(keys1, descriptors1, keys2, descriptors2, matches);
//}
et = cvGetTickCount();

printf(“match time: %f\n”, (et-st)/(double)cvGetTickFrequency()/1000.);
printf(“matchs num: %d\n”, matches.size());
[/cpp]
hamming距离测算通过查找表实现：
[cpp toolbar="true"]
unsigned int hamdist2(unsigned char* a, unsigned char* b, size_t size)
{
HammingLUT lut;

unsigned int result;
result = lut((a), (b), size);
return result;
}
[/cpp]

绘图：

[cpp toolbar="true"]
Mat showImg;
drawMatches(img2, keys2, img1, keys1, matches, showImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255));
string winName = “Matches”;
namedWindow( winName, WINDOW_AUTOSIZE );
imshow( winName, showImg );
waitKey();
[/cpp]

估计单应矩阵，计算重投影误差：

[cpp toolbar="true"]
Mat homo;

st = cvGetTickCount();
homo = findHomography(pt1, pt2, Mat(), CV_RANSAC, 5);
et = cvGetTickCount();
printf(“ransac time: %f\n”, (et-st)/(double)cvGetTickFrequency()/1000.);

printf(“homo\n”
“%f %f %f\n”
“%f %f %f\n”
“%f %f %f\n”,
homo.at(0,0), homo.at(0,1), homo.at(0,2),
homo.at(1,0), homo.at(1,1), homo.at(1,2),
homo.at(2,0),homo.at(2,1),homo.at(2,2));

vector
reproj;
reproj.resize(pt1.size());

perspectiveTransform(pt1, reproj, homo);

Mat diff;
diff = Mat(reproj) – Mat(pt2);

int inlier = 0;
double err_sum = 0;
for(int i = 0; i < diff.rows; i++){
float* ptr = diff.ptr(i);
float err = ptr[0]*ptr[0] + ptr[1]*ptr[1];
if(err < 25.f){
inlier++;
err_sum += sqrt(err);
}
}
printf(“inlier num: %d\n”, inlier);
printf(“ratio %f\n”, inlier / (float)(diff.rows));
printf(“mean reprojection error: %f\n”, err_sum / inlier);
[/cpp]

结果分析：

tem feat num: 743
orb2 extraction time: 1.672435
query feat num: 100
match time: 3.698276
matchs num: 8
ransac time: 143.570586
homo
0.974942 0.410833 4.426035
-0.182418 0.828115 52.742661
0.001191 0.000144 1.000000
inlier num: 8
ratio 1.000000
mean reprojection error: 0.976777

可见最近邻检索是系统的瓶颈，（进行了743*100次hamming距离（32bytes）计算。）一个简单的优化如下，分段计算hamming距离，先计算前16byte的hamming距离，如超过某一阈值，则直接认为非候选，如小于某阈值，则继续进行后一半16bytes的距离计算。（粗略估计可以减少30%+的最近邻查询时间）。更复杂的办法是使用LSH，此处按下不提，有空再续。

完整代码如下：

[cpp toolbar="true"]
#include “opencv2/objdetect/objdetect.hpp”
#include “opencv2/features2d/features2d.hpp”
#include “opencv2/highgui/highgui.hpp”
#include “opencv2/calib3d/calib3d.hpp”
#include “opencv2/imgproc/imgproc_c.h”
#include “opencv2/imgproc/imgproc.hpp”

#include
#include
#include

using namespace std;
using namespace cv;

char* image_filename1 = “apple_vinegar_0.png”;
char* image_filename2 = “apple_vinegar_2.png”;

unsigned int hamdist(unsigned int x, unsigned int y)
{
unsigned int dist = 0, val = x ^ y;

// Count the number of set bits
while(val)
{
++dist;
val &= val – 1;
}

return dist;
}

unsigned int hamdist2(unsigned char* a, unsigned char* b, size_t size)
{
HammingLUT lut;

unsigned int result;
result = lut((a), (b), size);
return result;
}

void naive_nn_search(vector& keys1, Mat& descp1,
vector& keys2, Mat& descp2,
vector& matches)
{
for( int i = 0; i < (int)keys2.size(); i++){
unsigned int min_dist = INT_MAX;
int min_idx = -1;
unsigned char* query_feat = descp2.ptr(i);
for( int j = 0; j < (int)keys1.size(); j++){
unsigned char* train_feat = descp1.ptr(j);
unsigned int dist = hamdist2(query_feat, train_feat, 32);

if(dist < min_dist){
min_dist = dist;
min_idx = j;
}
}

//if(min_dist <= (unsigned int)(second_dist * 0.8)){
if(min_dist <= 50){
matches.push_back(DMatch(i, min_idx, 0, (float)min_dist));
}
}
}

void naive_nn_search2(vector& keys1, Mat& descp1,
vector& keys2, Mat& descp2,
vector& matches)
{
for( int i = 0; i < (int)keys2.size(); i++){
unsigned int min_dist = INT_MAX;
unsigned int sec_dist = INT_MAX;
int min_idx = -1, sec_idx = -1;
unsigned char* query_feat = descp2.ptr(i);
for( int j = 0; j < (int)keys1.size(); j++){
unsigned char* train_feat = descp1.ptr(j);
unsigned int dist = hamdist2(query_feat, train_feat, 32);

if(dist < min_dist){
sec_dist = min_dist;
sec_idx = min_idx;
min_dist = dist;
min_idx = j;
}else if(dist < sec_dist){
sec_dist = dist;
sec_idx = j;
}
}

if(min_dist <= (unsigned int)(sec_dist * 0.8) && min_dist <=50){
//if(min_dist <= 50){
matches.push_back(DMatch(i, min_idx, 0, (float)min_dist));
}
}
}

int main(int argc, char* argv[])
{
Mat img1 = imread(image_filename1, 0);
Mat img2 = imread(image_filename2, 0);
//GaussianBlur(img1, img1, Size(5, 5), 0);
//GaussianBlur(img2, img2, Size(5, 5), 0);

ORB orb1(3000, ORB::CommonParams(1.2, 8));
ORB orb2(100, ORB::CommonParams(1.2, 1));

vector keys1, keys2;
Mat descriptors1, descriptors2;

orb1(img1, Mat(), keys1, descriptors1, false);
printf(“tem feat num: %d\n”, keys1.size());

int64 st, et;
st = cvGetTickCount();
orb2(img2, Mat(), keys2, descriptors2, false);
et = cvGetTickCount();
printf(“orb2 extraction time: %f\n”, (et-st)/(double)cvGetTickFrequency()/1000.);
printf(“query feat num: %d\n”, keys2.size());

// find matches
vector matches;

st = cvGetTickCount();
//for(int i = 0; i < 10; i++){
naive_nn_search2(keys1, descriptors1, keys2, descriptors2, matches);
//}
et = cvGetTickCount();

printf(“match time: %f\n”, (et-st)/(double)cvGetTickFrequency()/1000.);
printf(“matchs num: %d\n”, matches.size());

Mat showImg;
drawMatches(img2, keys2, img1, keys1, matches, showImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255));
string winName = “Matches”;
namedWindow( winName, WINDOW_AUTOSIZE );
imshow( winName, showImg );
waitKey();

vector
pt1;
vector
pt2;

for(int i = 0; i < (int)matches.size(); i++){
pt1.push_back(Point2f(keys2[matches[i].queryIdx].pt.x, keys2[matches[i].queryIdx].pt.y));

pt2.push_back(Point2f(keys1[matches[i].trainIdx].pt.x, keys1[matches[i].trainIdx].pt.y));
}

Mat homo;

st = cvGetTickCount();
homo = findHomography(pt1, pt2, Mat(), CV_RANSAC, 5);
et = cvGetTickCount();
printf(“ransac time: %f\n”, (et-st)/(double)cvGetTickFrequency()/1000.);

printf(“homo\n”
“%f %f %f\n”
“%f %f %f\n”
“%f %f %f\n”,
homo.at(0,0), homo.at(0,1), homo.at(0,2),
homo.at(1,0), homo.at(1,1), homo.at(1,2),
homo.at(2,0),homo.at(2,1),homo.at(2,2));

vector
reproj;
reproj.resize(pt1.size());

perspectiveTransform(pt1, reproj, homo);

Mat diff;
diff = Mat(reproj) – Mat(pt2);

int inlier = 0;
double err_sum = 0;
for(int i = 0; i < diff.rows; i++){
float* ptr = diff.ptr(i);
float err = ptr[0]*ptr[0] + ptr[1]*ptr[1];
if(err < 25.f){
inlier++;
err_sum += sqrt(err);
}
}
printf(“inlier num: %d\n”, inlier);
printf(“ratio %f\n”, inlier / (float)(diff.rows));
printf(“mean reprojection error: %f\n”, err_sum / inlier);

return 0;
}

[/cpp]

图像缩放是最常用的图像操作，最近实现了一次双线性插值，适用于单通道8位灰度图像，可以同时处理缩小，放大。

加速手段有三个：

1：使用可分离方式，先后处理行和列

2：构建缓冲区，以避免对某些行重复插值。

3：使用整形运算，避免浮点运算。

performace:

测试图像： C:\Documents and Settings\All Users\Documents\My Pictures\示例图片\Water lilies.jpg

上表都是执行1000次的总时间，可以看出，在缩小时速度比opencv的cvResize相当，在放大时，不幸的比cvResize慢上50%。贴出代码求解。

[cpp toolbar="true"]
typedef struct _Image{
int w;
int h;
int c;
int step;
int type;
void* data;
} Image;

static void _ieInterpImageBilinear8UC1_RowFilter(unsigned char* src, long* dst, int len, int* leftIdx, int* rightIdx, long* weight, int shift)
{
int i, j;
for(i = 0, j = 1; i < len - 2; i+=2, j+=2){
dst[i] = ((1< dst[j] = ((1<

}
for( ; j < len; j++){
dst[j] = ((1< }
}

static void _ieInterpImageBilinear8UC1(Image* src, Image* dst)
{
int i, j;
int sw, sh, sstep;
int dw, dh, dstep;
unsigned char *sdata, *ddata;
float horScaleRatio, verScaleRatio;
long *rowBuf1, *rowBuf2;
long *upLinePtr, *downLinePtr, *tempPtr;
long *horWeight;
int *horLeftIdx, *horRightIdx;
int preVerUpIdx, preVerDownIdx;
int shift = 8;

sw = src->w; sh = src->h; sstep = src->step; sdata = (unsigned char*)(src->data);
dw = dst->w; dh = dst->h; dstep = dst->step; ddata = (unsigned char*)(dst->data);

horScaleRatio = sw / (float)(dw);
verScaleRatio = sh / (float)(dh);

rowBuf1 = new long[dw];
rowBuf2 = new long[dw];
horWeight = new long[dw];
horLeftIdx = new int[dw];
horRightIdx = new int[dw];

//col interpolation
//计算目标图像像素横向的左右邻居序号，和权重。
for(i = 0; i < dw; i++){
float pos = (i + 0.5f) * horScaleRatio;
horLeftIdx[i] = (int)(IET_MAX(pos - 0.5f, 0));
horRightIdx[i] = (int)(IET_MIN(pos + 0.5f, sw-1));
horWeight[i] = (long) (fabs(pos - 0.5f - horLeftIdx[i]) * (1< }

preVerUpIdx = -1;
preVerDownIdx = -1;
upLinePtr = rowBuf1;
downLinePtr = rowBuf2;
for(j = 0; j < dh; j++){
float pos = (j + 0.5f) * verScaleRatio;
int verUpIdx = (int)(IET_MAX(pos - 0.5f, 0));
int verDownIdx = (int)(IET_MIN(pos + 0.5f, sh-1));
long verWeight = (long) (fabs(pos - 0.5f - verUpIdx) * (1<

if(verUpIdx == preVerUpIdx && verDownIdx == preVerDownIdx){
;//do nothing
}
else if(verUpIdx == preVerDownIdx){
IET_SWAP(upLinePtr, downLinePtr, tempPtr);
_ieInterpImageBilinear8UC1_RowFilter(sdata + sstep*verDownIdx, downLinePtr, dw, horLeftIdx, horRightIdx, horWeight, shift);
}else{
_ieInterpImageBilinear8UC1_RowFilter(sdata + sstep*verUpIdx, upLinePtr, dw, horLeftIdx, horRightIdx, horWeight, shift);
_ieInterpImageBilinear8UC1_RowFilter(sdata + sstep*verDownIdx, downLinePtr, dw, horLeftIdx, horRightIdx, horWeight, shift);
}

for(i = 0; i < dw; i++){
ddata[dstep*j + i] = (unsigned char) ( (((1<> (2*shift) );
}
preVerUpIdx = verUpIdx;
preVerDownIdx = verDownIdx;
}
delete []rowBuf1;
delete []rowBuf2;
delete []horWeight;
delete []horLeftIdx;
delete []horRightIdx;
}
[/cpp]

使用神奇的四次展开循环，速度提升15%+。
code如下。
[cpp toobar="true"]
static void _ieInterpImageBilinear8UC1_Ver3_RowFilter(unsigned char* src, long* dst, int len, int* leftIdx, int* rightIdx, long* weight, int shift)
{
int i;
for(i = 0; i < len - 4; i+=4){
*dst++ = ((1< *dst++ = ((1< *dst++ = ((1< *dst++ = ((1<

}
for( ; i < len; ++i){
*dst++ = ((1< }
}

static void _ieInterpImageBilinear8UC1_Ver3(Image* src, Image* dst)
{
int i, j;
int sw, sh, sstep;
int dw, dh, dstep;
unsigned char *sdata, *ddata;
float horScaleRatio, verScaleRatio;
long *rowBuf1, *rowBuf2;
long *upLinePtr, *downLinePtr, *tempPtr;
long *horWeight;
int *horLeftIdx, *horRightIdx;
int preVerUpIdx, preVerDownIdx;
int shift = 8;

sw = src->w; sh = src->h; sstep = src->step; sdata = (unsigned char*)(src->data);
dw = dst->w; dh = dst->h; dstep = dst->step; ddata = (unsigned char*)(dst->data);

horScaleRatio = sw / (float)(dw);
verScaleRatio = sh / (float)(dh);

rowBuf1 = new long[dw];
rowBuf2 = new long[dw];
horWeight = new long[dw];
horLeftIdx = new int[dw];
horRightIdx = new int[dw];

//col interpolation
//计算目标图像像素横向的左右邻居序号，和权重。
for(i = 0; i < dw; i++){
float pos = (i + 0.5f) * horScaleRatio;
horLeftIdx[i] = (int)(IET_MAX(pos - 0.5f, 0));
horRightIdx[i] = (int)(IET_MIN(pos + 0.5f, sw-1));
horWeight[i] = (long) (fabs(pos - 0.5f - horLeftIdx[i]) * (1< }

preVerUpIdx = -1;
preVerDownIdx = -1;
upLinePtr = rowBuf1;
downLinePtr = rowBuf2;
for(j = 0; j < dh; j++){
float pos = (j + 0.5f) * verScaleRatio;
int verUpIdx = (int)(IET_MAX(pos - 0.5f, 0));
int verDownIdx = (int)(IET_MIN(pos + 0.5f, sh-1));
long verWeight = (long) (fabs(pos - 0.5f - verUpIdx) * (1<

if(verUpIdx == preVerUpIdx && verDownIdx == preVerDownIdx){
;//do nothing
}
else if(verUpIdx == preVerDownIdx){
IET_SWAP(upLinePtr, downLinePtr, tempPtr);
_ieInterpImageBilinear8UC1_Ver3_RowFilter(sdata + sstep*verDownIdx, downLinePtr, dw, horLeftIdx, horRightIdx, horWeight, shift);
}else{
_ieInterpImageBilinear8UC1_Ver3_RowFilter(sdata + sstep*verUpIdx, upLinePtr, dw, horLeftIdx, horRightIdx, horWeight, shift);
_ieInterpImageBilinear8UC1_Ver3_RowFilter(sdata + sstep*verDownIdx, downLinePtr, dw, horLeftIdx, horRightIdx, horWeight, shift);
}

unsigned char* _ptr = ddata + dstep*j;
for(i = 0; i < dw-4; i+=4){
*_ptr++ = (unsigned char) ( (((1<> (2*shift) );
*_ptr++ = (unsigned char) ( (((1<> (2*shift) );
*_ptr++ = (unsigned char) ( (((1<> (2*shift) );
*_ptr++ = (unsigned char) ( (((1<> (2*shift) );
}
for(; i < dw; i++){
*_ptr++ = (unsigned char) ( (((1<> (2*shift) );
}
preVerUpIdx = verUpIdx;
preVerDownIdx = verDownIdx;
}
delete []rowBuf1;
delete []rowBuf2;
delete []horWeight;
delete []horLeftIdx;
delete []horRightIdx;
}
[/cpp]

闲来做了下logo检测，拿大众车标测试：

intel core2 2.8G，320×240的图像，5ms每帧。

algorithm：类HoG Feature+SVM

更多效果图：

做图像处理经常需要可视化中间过程，伪彩色是常用的工具。以前都是手动指定几个颜色，今天看到computer vision：algorithm and application里面提到一种伪彩色生成办法，Szeliski描述如下：

For each (non-negative) label value, consider the bits as being split among the three color

channels, e.g., for a nine-bit value, the bits could be labeled RGBRGBRGB. After collecting

each of the three color values, reverse the bits so that the low-order bits vary the most quickly.

For each (non-negative) label value, consider the bits as being split among the three colorchannels, e.g., for a nine-bit value, the bits could be labeled RGBRGBRGB. After collectingeach of the three color values, reverse the bits so that the low-order bits vary the most quickly.

尝试实现了一下，code:

[cpp toolbar="true"]// PseudoColor.cpp : Defines the entry point for the console application.
//

#include “stdafx.h”
#include
#include
#include

#include “cxcore.h”
#include “cv.h”
#include “highgui.h”

#define DEFAULT_BITS_PER_CHANNLE 4
#define BITS_TOTAL (3*BITS_PER_CHANNLE)

unsigned char* gen_pseudo_color_lut(int bit_per_channle)
{
int bits_total = 3*bit_per_channle;
int color_num = 1 << bits_total;
unsigned char* lut = (unsigned char*) malloc(3*color_num*sizeof(unsigned char));
assert(bit_per_channle < 8);

for(int c = 0; c < color_num; c++){
int r = 0;
int g = 0;
int b = 0;
for(int k = 0; k < bits_total; ){
b = (b << 1) + ((c >> k++) & 1);
g = (g << 1) + ((c >> k++) & 1);
r = (r << 1) + ((c >> k++) & 1);
}
r = r << (8 – bit_per_channle);
g = g << (8 – bit_per_channle);
b = b << (8 – bit_per_channle);

lut[3*c] = r; lut[3*c+1] = g; lut[3*c+2] = b;
}

return lut;
}

int _tmain(int argc, _TCHAR* argv[])
{
unsigned char* lut = gen_pseudo_color_lut(DEFAULT_BITS_PER_CHANNLE);
int color_num = 1 << (3*DEFAULT_BITS_PER_CHANNLE);

FILE* fp = fopen(“lut.txt”, “wt”);
fprintf(fp, “static unsigned char[%d] = {“, color_num);
for(int c = 0; c < color_num; c++){
printf(“c = %d, (r,g,b) = (%d, %d, %d)\n”, c, lut[3*c], lut[3*c+1], lut[3*c+2]);

if(c != color_num-1)
fprintf(fp, “%d, %d, %d, “, lut[3*c], lut[3*c+1], lut[3*c+2]);
else
fprintf(fp, “%d, %d, %d};\n”, lut[3*c], lut[3*c+1], lut[3*c+2]);
}
fclose(fp);

//stripe show case.
int w = 640;
int h = 240;
IplImage* gray = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 1);
for(int y = 0; y < h; y++){
for(int x =0; x < w; x++){
CV_IMAGE_ELEM(gray, unsigned char, y, x) = x / 4;
}
}

IplImage* color = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 3);
for(int y = 0; y < h; y++){
for(int x = 0; x < w; x++){
int c = CV_IMAGE_ELEM(gray, unsigned char, y, x);
CV_IMAGE_ELEM(color, unsigned char, y, 3*x) = lut[3*c+2];//b
CV_IMAGE_ELEM(color, unsigned char, y, 3*x+1) = lut[3*c+1];//g
CV_IMAGE_ELEM(color, unsigned char, y, 3*x+2) = lut[3*c];//r
}
}

cvNamedWindow(“gray”);
cvNamedWindow(“color”);
cvShowImage(“gray”, gray);
cvShowImage(“color”, color);
cvWaitKey(0);

free(lut);
cvReleaseImage(&gray);
cvReleaseImage(&color);
return 0;
}[/cpp]

下面一张不是全景图。照的是一个9屏的电影，万重浪（ten thousand waves)，9个屏，分别显示不同的视角，注意上面的白色投影仪。我去晚了，只看到了尾巴，没搞清楚放的什么玩意。。不过，号称艺术嘛，估计我就算看完整了，也一样搞不清楚放的什么玩意。额。。。

图像较大，请耐心等待图片下载。建议点击右上角的图标全屏观看。

亲爱的读者，这个算法效果如何？ 请写下您的看法哈。用阅读器的朋友请点这里。

喜爱这个图像处理demo展示flash的读者，请不要吝啬对terri的赞美。

对这个flash相册感兴趣的朋友可以直接拿源码了：

http://code.google.com/p/demoforimageprocess/

参考资料可以仍然用Computer vision: algorithm and applications，draft March 24 2010, chapter 2.1.5

由于练习描述比较长，就不直接贴在帖子里了。请下载练习：

cvexercise2questions

参考report：

cvexercise2 report

参考matlab code （因为仍然是贴在pdf中的，所以同样注意换行错误）：

cvexercise2code

enjoy!!!!

参考书籍可以用前些天发的一个帖子推荐的那本书，Computer vision: algorithm and applications，draft March 24 2010, chapter 2.1.5。自己稍微翻看了一下这本书，相当相当不错，非常非常与时俱进。。。同推荐一下。。。

Calibrate a simulated camera

Description: Calibrate a simulated camera. Construct the transformation matrix from a set of
parameters. Get 3D and 2D points. Calibrate by using the method of Hall. Check the accuracy
against the increase of noise in the image points.
Programming platform: Matlab
Part 1
Step 1. Define the intrinsic parameters and extrinsic parameters with the following values:
au=557.0943; av=712.9824; u0=326.3819; v0=298.6679;
f=80 mm.;
Tx=100 mm.; Ty=0 mm.; Tz=1500 mm.;
Phix=0.8*pi/2; Phiy=-1.8*pi/2; Phix1=pi/5; Euler XYX1
Image size:640×480
Step 2. Get the intrinsic and extrinsic transformation matrices
Step 3. Define a set of 3D points in the rang [-480:480;-480:480;-480:480]. Note the points
should be non-linear and non-coplanar. At least you need to define a set of 6 points. It’s not
necessary to demonstrate mathematically the non-linearity/non-coplanarity, just define 6 points
randomly in the 3D space.
Step 4. Compute the projection on the image plane by using the camera transformation matrix.
Do not remove the subpixel precision of the obtained points.
Step 5. Open a window in matlab which will be used as the image plane and draw the 2D
points. Are the points well spread in the image plane? Will the distribution of points in the image
affect the accuracy in the computation?
Step 6. By using the points of Step 3 and their projection obtained in Step 5, compute the 3×4
transformation matrix by using the method of Hall.
Step 7. Compare the matrix obtained in Step 6 to the one defined in step 2.
Step 8. Add some Gaussian noise to the 2D points producing discrepancies between the range
[-1,+1] pixels for the 95% of points. Again repeat step 6 with the noisy 2D points and the ones
defined in step 3. Compare the obtained matrix to the one you got in step 6 with the non-noisy
points.
Step 9. Increase the number of 3D points up to 10 points and then up to 50 points and repeat
step 8. More the points we use more accurate is the matrix obtained.
Part 2.
Step 10. Define the vector X of the method of Faugeras. Compute X by using both leastsquares
(LS) and Singular Value Decomposition (SVD) by using the points of step 3 and 4,
without noise. Extract the camera parameters from both computations. Compare the obtained
parameters with the ones defined in Step 1.o
Step 11. Add Gaussian noise to the 2D points (produce noise so that the 95% is in the rang
[-1,1], then in the rang [-2,2] and finally in the rang [-3,3] ) and compute vector X (repeat step
10) for each rang. Which are the parameters more influenced by noise? Which method of
computation is more accurate (LS or SVD)? Which method is more accurate (Faugeras or Hall)
with such noise?
Part 3.
Step 12. Open another window in matlab and draw the world coordinate system, the camera
coordinate system, the focal point, the image plane, and both 3D points and their corresponding
projections on the image plane by using the parameters of step 2 and points without noise.
Check if camera position corresponds to (tx, ty, tz) defined in step 2. Check if all the optical rays
cross at the focal point? Check if 2D points lie on the optical rays defined by the 3D points?

由于练习来自于原来上课的练习，所以有些符号，例如au,av之类是跟据当时课件定义的。如果有些童鞋对这些符号不清楚，可以参考附件中的report。

camera calibration report：实在找不到当时写的完整的report了，只找到了这个draft。将就用一下吧，的确是有问题的，比如step11就完全没有写，而且连图都没有，囧！不过后面我会上传全部的matlab code，不清楚话可以看code。希望之后的一些练习能找到完整的report。

MATLAB CODE:

matlab code for camera calibration

尝试上传.m格式和.rar格式的文件不成功，只好把code粘到了pdf里，大家用的时候小心换行造成的错误。。。有谁知道该怎么解决这种上传的问题啊？

上海外滩全景

上海外滩，点击图片看大图，拼接工具hugin

另：由于专利问题，hugin的最新版本去掉了sift相关的特征点提取工具。解决办法是先安装hugin 0.7版，然后用最新版本覆盖安装。