常用的三种类型的深度相机^[1]，大致分为以下三种：基于主动投射结构光的深度相机（如Kinect 1.0, Intel RealSense, Enshape, Ensenso等）、被动双目相机（如STEROLABS 推出的 ZED 2K Stereo Camera, Point Grey 公司推出的 BumbleBee）以及ToF^[2]相机（如微软的Kinect 2.0, MESA 的 SR4000 , Google Project Tango 中使用的PMD Tech 的TOF相机，Intel 的 SoftKinect DepthSense, Basler基于松下的芯片开发的TOF相机以及国内一些初创公司基于TI的方案开发的TOF相机等等）

目前市面上常有的 3D 相机方案就就是下面3种，对应上面的：
(1) 结构光(Structured-light)，代表公司有奥比中光（国产，比较推荐，性价比可以，也有高分辨率的款），苹果(Prime Sense)，微软 Kinect-1，英特尔RealSense, Mantis Vision 等。
(2) 双目视觉(Stereo)，代表公司 Leap Motion， ZED， 大疆;
(3) 光飞行时间法(TOF)，代表公司微软 Kinect-2，PMD，SoftKinect， 联想Phab。

image_1cs5el5cb14m9bhr9ts11rvgve4i.png-82.7kB

1. Kinect

先给出结论，KinectV2的精度在2mm~4mm左右，距离越近精度越高，越远精度稍微差点；kinectV1误差约2mm~30mm。

Kinectv2 for Mobile Robot Navigation: Evaluationand Modeling

• Kinect v2在不同位置的精度问题

image_1cs6h8fbdokn1ljf1npuogg1g2b5p.png-1587.5kB

如上图所示，右侧大三角是KinectV2在纵向（垂直于地面）的精度分布，下侧大三角是KinectV2在水平面（平行于地面）上的精度分布。在绿色区域精度最高，误差小于2mm，在黄色区域误差在2~4mm，红色区域误差大于4mm。所以在设计交互场景时，在黄色区域以内会达到最好的效果（3.5m内）。如果对精度要求很高，如控制机械，最好在绿色区域进行交互。

2 Kinect v2和Kinect v1

性能表对比

Kinect v2的rgb视场（FOV^[3]）是84.1 x 53.8，关于FOV的建模和模型可以参考。

image_1cs6hgs884u61c4cs061tp61d9466.png-274.2kB

如图所示，KinectV1随着距离增加，误差指数性增加，在距离达到4m时，kinectV1误差接近0.2m。而KinectV2的误差几乎不随距离增加而变化。V2比V1追踪准确度好20%。V2可以在户外进行人体跟踪，最远到4m。V2在近距离有比V1高2倍的精度，在6m有高数十倍的精度。

• kinectv1和kinectv2比较

• |KinectV1|KinectV2
  ----|----|----
  检测范围(Range of Detecton)|0.8–6.0m|0.5 –4.5m
  深度误差(depth Uncertainty)|2mm-30mm|<0.5% of range
  角度(Angle，horizontal-vertical)|57-43|70-60

3. LeapMotion

LeapMotion的精度平均下来是0.7mm的精度，也是达不到所谓的0.01mm的。

Analysis of the Accuracy and Robustness of the Leap
Motion Controller

上面的论文对初步版本中的Leap Motion控制器进行研究，分别在静态与动态设置下的精度和准确性，考虑到人手的可达到的平均约为0.4mm，实验用设备使用参考笔，位置精度可达0.2mm，且参考笔对仪器精度测量无可观察到的影响。在基于静态设置的测量下，获得了期望的3D位置与小于0.2mm的测量位置之间的与轴无关的偏差。在动态情况下，独立于平面，可以获得小于2.5mm的精度（平均1.2毫米）。重复性平均小于0.17毫米。在基于姿势的用户界面方面，在实际条件下不可能实现0.01mm的理论精度，而是高精度（总平均精度为0.7mm）。

最后比较一下以上设备的优缺点

1. Microsoft Kinect

image_1cs835f4eiaa4gb1ln31cndcb2an.png-99.9kB

优点：

• 可以获取深度数据（320＊240）、rgb
• 数据（640＊480）、声音、骨骼节点（20个）
• 拥有三套 SDK：微软 SDK、OpenNI、libfreenect
• 后两个 SDK 是跨平台，支持各种开发语言
• 价格便宜
• 社区成熟，开发资源丰富

缺点：

• 传感器分辨率不够，看不清手指
• 由于使用结构光技术，深度传感器的可视范围无法重叠
• OpenNI 和 libfreenect 虽然跨平台，但是功能远不如微软 SDK
• 设备尺寸大，需要一坨电源线
• 致命缺点，微软已宣布停止生产 Kinect 一代

2. Microsoft Kinect One

image_1cs83c41h1bpip0qjqvc2s1aub4.png-84.5kB

优点：

• 分辨率更大、可以看到更广阔的场景
• 可以检测到的人体关节点更多（25个），能看清手指
• 拥有两套 SDK：微软 SDK、libfreenect2
• 可以开发 Windows Store 应用

缺点：

• libfreenect2 基本不能检测骨骼，功能缺太多，同时 OpenNI 也不支持它，因此局限于 Windows 平台
• 设备尺寸比一代更大，需要一坨电源线，比一代贵一些
• 致命缺点：只能运行在 64 位 Windows 8 系统上，必须使用 USB 3.0 端口

3. Intel / Creative / SoftKinetic

image_1cs83s6uv6941lg0gaonlg1ocp19.png-259.3kB

优点：

• 小巧，普通 USB 摄像头的尺寸
• 不需要外界电源线
• 近距离使用，可实现表情分析和手势识别

缺点：

• 不适合远距离交互，也无法检测完整的身体
• 只能在中高端的 Intel CPU 上才能运行

4. Leap Motion

image_1cs83t6bukpppr9f021dtt1cdo1m.png-170.4kB

优点：

• 小巧，一根 usb 线就可以使用
• 跨平台
• 支持的开发语言比较多，甚至通过 WebSocket
• 实现了浏览器中的 JavaScript API
• 跟踪手指和手掌，精度较高

缺点：

• 检测范围小，手臂酸疼（见上图）
• 不能检测身体和脸部
• 作为生产力工具，完全无法替代鼠标键盘
• 致命缺点：找不到合适的使用场景

5. PrimeSense / Apple / 华硕（ASUS）

image_1cs8479dm6sncqr1ulgb1e1l5r23.png-80.6kB

和 Kinect 一代的优缺点类似，

1. https://zhuanlan.zhihu.com/p/28274727 ↩

2. https://baike.baidu.com/item/TOF/19952376?fr=aladdin ↩

3. http://www.coloreye.cn/wiki/doc-view-716.html ↩

• 证明末动能小于初动能：

牛顿定律 ，Fi是第i个物体受的合力

咱们用T表动能

而 i表内，e表外

积个分

这是动能定理

如果非弹性碰撞的话，物体在受挤压力的时候向内凹陷，一定有内力负功，还有很少摩擦力，按物理语言，这些功转成了热

所以动能关系

• 动量守恒：

而物体间内力是成对出现的

我们还有牛顿第三定律：

所以合力的冲量元即为合外力的冲量元

用Ii表示第i个物体受合外力的冲量

所以动量定理的微分式我们也有了，I是体系合外力的冲量

碰撞的话，一瞬间质点系的合外力为零

自然有

所以积分后就有我们的动量守恒律：

认识中通数字高尔夫 

   认识中通数字高尔夫

     北京中通数字高尔夫以国家飞行仿真模拟实验室为技术依托，主要从事计算机仿真软件开发及相关工程的设计、实施和服务，是国内最早研发、生产和销售模拟高尔夫系统的高科技公司及中国最大的高尔夫模拟器销售商。

    基于北京中通数字高尔夫的多年模拟系统的开发实施经验，EDH公司与北京中通数字高尔夫在中国进行了广泛的合作，共同成立了北京数字化球场制作研发中心、软件研发中心。EDH公司指定中通数字高尔夫公司为其全球领先的FlightScope高尔夫雷达产品在中国市场的总代理，全面负责FlightScope相关产品在中国的销售、安装及售后服务。  　　

  根据考古研究，我们已知最早的文明，两河文明，已经让初等数学在他们的生活中起到了不小的作用。巴比伦人的天文知识渊博而精确，例如关于太阳月，他们定出的值与真实值之间只差一秒。他们不光熟悉十进制，在计算大数的时候还补充了一种以六十为基数的进位制。一块距今约4300年的泥板表明，巴比伦人那时已经知道如何度量矩形、特殊三角形的面积，以及正多面体的体积。

  在外来者当中，有些人把苏美尔的影响和知识带到了埃及，在这里，文明也达到了很高的成就。因为纸草书的存在，我们对埃及的了解比对巴比伦的要多。埃及人对数学有着广泛的贡献，他们完成了基本的算数四则运算，并把它们推广到分数上，并且有了求近似平方根的方法。他们已经有了算数级数，几何级数，立体图形求积，初等三角函数以及二次方程的知识。然而，无论是巴比伦人还是埃及人，都没有对自然现象进行耐心仔细的考察，拥有概括推理的能力，因此这些古老的文明中并没有产生真正意义上的科学。

  虽然希腊人从古代文化中继承了大量资料，不过几乎所有人都承认，爱琴海的艾奥尼亚海岸是今天一切科学的起源。巴比伦人和埃及人从未想到过为了知识本身而去寻求知识的行为，而正是这种概念促使了“希腊的科学奇迹”的发生，这之中最惊人的进步便发生在数学上，并为其以后的发展奠定了永久的基础。以泰勒斯为首的艾奥尼亚学派将几何学等知识从埃及和巴比伦带回希腊，并提出了很多命题和基本原理。公元前6世纪末，由于波斯的入侵，人们向西方逃难，意大利和西西里岛变成了新的学术中心。建立于意大利南部的毕达哥拉斯学派把数学研究变成了一种自由教育的形式，整个数学变得更抽象，更加脱离经济生活需要了。毕达哥拉斯学派对数学发展产生了巨大影响，历时达两个世纪之久。

  波斯于公元前480年被希腊联军击败后，雅典成为了世界经济和文化中心。这时出现了旨在教育国民，转播文化的哲人派，他们的思考对尺规作图等几何问题的发展影响很大，其中就有芝诺那些关于无限的著名悖论。波斯游牧民族的威胁消除后，雅典与斯巴达之间的同盟就被猜忌与不和取代了。伯罗奔尼撒战争一直延续到公元前404年，那一年雅典被迫投降。这段时期是苏格拉底和柏拉图的时代。与老师苏格拉底醉心于国家和伦理不同，柏拉图在游历期间对数学产生了浓厚的兴趣。因此对后世影响深远的柏拉图学园的哲学也成了数学的哲学。伟大的学者，哲学家亚里士多德也是柏拉图学园的学生，他让人们明白了公理，公设和定义之间的区别，他的著作包含很多重要的定理。亚里士多德留下的大量著作，直接统治了后来的“复兴时期”的所有学说，即使那些错误的力学原理一直持续到16世纪。

  马其顿于公元前338年彻底击败雅典后，雅典城再也没能复兴起来。两年后，马其顿的新国王亚历山大大帝开始着手征服世界，建立了巨大而短暂的帝国。公元前332年，他在尼罗河畔建立了亚历山大城。这座城市后来的统治者托勒密与亚历山大大帝一样都是亚里士多德的学生，亚历山大城很快成为了新的经济与文化中心。从那以后，亚历山大这种学术中心的地位延续了千年，直到公元641年遭到阿拉伯人的洗劫。

  亚历山大城的学者中，有三个人决定了此后数百年数学的进程：欧几里得，阿基米德与阿波罗尼奥斯。于公元前320年由欧几里得编写的《几何原本》是欧式几何的奠基之作。欧几里得使用了公理化的方法，这一方法后来成了建立任何知识体系的典范，在两千年间被奉为必须遵守的严密思维的范例。阿基米德被称为古代最伟大的数学家。他的发现涉猎极广，如给出许多求几何图形重心，包括由一抛物线和其网平行弦线所围成图形的重心的方法，还有采用不断分割法求椭球体、旋转抛物体等的体积，这种方法已具有积分计算的雏形。阿波罗尼奥斯是天才的几何学家，著有《圆锥曲线》一书，它将圆锥曲线的性质网罗殆尽，几乎使后人没有插足的余地。

  公元元年以后，虽然在亚历山大的数学研究还在继续着，但人们对于这门学科的兴趣在逐渐减弱。希腊科学的黄金时代正在消褪，取而代之的是极端实际与不关心智慧追求的罗马文化，随后则是长达一千年的中世纪。这是黑暗的时代，希腊先哲们的荣光似乎远离了这块土地，无论是数学，还是其他思想，大都处于停滞乃至衰落状态。然而，天翻地覆的巨变正在缓缓酝酿着，而最终带来的，将是一场彻底的光明与复兴。

  虽然文艺复兴被普遍认为是“人类从来没有经历过的最伟大的、进步的变革”，不过对于数学而言，智慧的火焰在黑暗时期也在不停地涌现，反抗着。东方的拜占庭帝国一直维持着一个学术背景，保存了不少希腊学术著作。阿拉伯人崛起后，很快从东西方的合流中发展出了高度的文化，希腊文化也由此保留。基督教征服西班牙后，阿拉伯文化被西欧所利用，大量希腊著作被译为拉丁文。中国的指南针传到西方后，提高航海技术的强烈需要极大地影响了天文学和数学两门基础科学。不过中世纪的人们过于尊敬亚里士多德的权威地位，以至于出现了纯粹解释历史文献的学问。这与自然科学的理念背道而驰，在这样的气氛里，数学只能勉强维持下来。

  1453年，君士坦丁堡被土耳其人攻陷。继承了罗马和希腊，绵延千年的拜占庭帝国覆灭。许多学者带着著作来到意大利避难，受到了美第奇家族的欢迎。西方终于能够直接看到希腊经典著作的原文，而整个西方世界也揭开了那个最有名的繁盛时期。

  数学在这个全面复兴的局面中没有落后，不久它就获得了自从希腊文化衰落以来从未有过的领导地位。以前一直被忽视的算数开始兴起，三次和四次方程的解已经得出，负数甚至虚数获得了应有的地位，三角学开始作为一门独立学科出现，而属于物理学范畴却对本文及其重要的一个事实是：沉寂了18个世纪的力学，终于开始吸引人们的注意了。文艺复兴始于当时最强盛的意大利和德国，汉萨联盟仍然控制着北方的贸易，而佛罗伦萨和威尼斯正处于繁荣昌盛的顶峰。法国的重要性直到16世纪末才表现出来，并牢牢占据领导地位达一个世纪之久。

  1600年可能是数学史上最重要的一个世纪的开端。笛卡尔在此四年前出生，随后又有帕斯卡尔和费马诞生。这三个人注定要改变整个数学面貌。在16世纪，大多数数学科目都有了具体的进展，不过新世纪的开始预告了一个更为壮观的发展。代数在几何上的运用使笛卡尔让解析几何臻于完善，帕斯卡尔发展了射影几何，小数和对数的应用提升了计算方法，费马等人开始研究数论和概率论，古代极微分割方法被引人几何学，并最终导致了微积分的发明。在开普勒等前人的基础上，笛卡尔和费马分别发明了解析几何。笛卡尔的《几何学》是论述解析几何的一部经典之作。而对于概率论最早的探索，要归功于费马和帕斯卡尔。这一研究经过了漫长的历史，直到如今，仍然在吸引着众多科学家的注意力。

  随着数学的稳步前进，力学一直落在后面。虽然阿基米德指出过正确的方向，但在1800年来取得的进展很小。不过16世纪末开始，由于出现了机器，力学原理的研究终于开始了。伽利略，笛卡尔，惠更斯等人对这门学科做了极大的拓展。不过在他们手里，力学已经达到了这样的高度：如果不发明新的，更有力的方法，就几乎不可能取得进一步进展了，而同时期的数学的处境也差不多。幸运的是，这种现象并没有被耽搁很久，因为在1642年，牛顿出生了。

  微积分并非没有前身突然产生的，它是许多学者长期探索的思想结晶。在确定曲线图形的面积问题上，阿基米德曾用到了穷竭法，从中可以清楚地看到无穷小的分析原理，2000年后卡瓦列里又恢复了这方面的探索，经过托里拆利，费马，惠更斯，沃利斯等人的推广与改进，形成了积分学中求和的形式。在做曲线切线的问题上，阿基米德的螺线切线之后，笛卡尔和费马又做出了发展。

  牛顿的万有引力定律与二项式定理是伟大的贡献，而其不朽著作《原理》标志着经典力学体系的建立。其全书贯穿了流数，也就是微积分的概念。牛顿的重要性在于，他集各家之大成，提出了变化率，微分与积分互逆等微积分的基本概念，并把这个方法变成了一个完整的工具体系。在德国，微积分的原理是由莱布尼兹发展起来的。根据莱布尼兹自述，他是在1674年发明微积分的，牛顿声称他逐渐攻下流数是在1666年。由此，英国与欧洲大陆数学家分道扬镳，这是科学史上不幸的一章。在这场争论中，莱布尼兹的记法被用到了今天，而现在人们公认牛顿和莱布尼兹是各自独立创建微积分的。微积分的创立，标志着世界进入一个新纪元。从17世纪起，科学就开始将原来以基督教为中心的文化变革成现在这样以科学为中心的文化。

  1640年英国资产阶级革命后，英国确立了君主立宪制，世界进入了近代史时期。1701年普鲁士王国成立，1776年美国独立，1789年法国大革命，封建制度的衰亡和资本主义的成长是这一时期的中心内容，英国、德国、法国成为这一时期数学家的主要家园。在17世纪后半叶，数学取得了惊人的进展，微积分是强有力的工具，但必须批判地考察其基础。这就是下一个世纪的主要工作之一。在18世纪，数学的主流是由微积分发展起来的数学分析。数学分析的发展使力学和天体力学深化，而后者的课题又成了数学分析发展的动力。

  从数学家的角度而言，18世纪是“英雄的时代”，各路豪杰尽显威名，包括科学史上著名的伯努利家族；几乎对每个数学分支都做出了重要贡献的欧拉；赋予微积分清楚严谨的基础的柯西；18世纪最顶级的数学家拉格朗日；此外还有泰勒，麦克劳林，斯特林，兰登，傅里叶，等等，他们为发展微积分做出了突出贡献。而蒙日，卡诺和彭塞列则创立了近代几何的开端。拉格朗日于1766年受腓特烈大帝邀请来到柏林。这20年里，他的作品浩如烟海，并酝酿了他最伟大的著作《分析力学》。 当时，法国土地上的复兴气象正开始生成，巴黎再度成为数学教育中心。拉普拉斯和拉格朗日一样是分析学大师，他在天文力学上取得了惊人的成果，著有《天体力学》一书。 随着拿破仑的铁骑横扫欧陆，这个时代也是法国历史上科学成就最丰富的时代之一。

18世纪末，法兰西的土地上已经取得了最大进展。随着19世纪的到来，德国很快跃居首位。高斯，阿贝尔，伽罗华等人发扬了费马在代数上的贡献。高斯是这个时代乃至所有时代最伟大的数学家，他对数学的严密性有更高的要求，他全面发展了纯粹数学和应用数学的所有领域。 由于高斯进行了各种各样的研究，数学已经变得越来越高度专门化了，更加脱离了经济生活的需要，学者们开始培养起为数学而研究数学的兴趣。

  1897年召开了国际数学家大会，揭开了20世纪纯粹数学大发展的时代，数学的分支很快变得越来越多，其中每个都是需要专家来研究的一门科目。企图涉猎整个领域的最后一人是庞加莱，目前来看，即使有第二个高斯出现，他能否涉及极少几个分支而显得游刃有余，那都是值得怀疑的。数学已经发展成为一个如此巨大的结构，对各个学科起着基石作用，而如今我们可以毫不含糊地说：数学就是一切科学之王。

极简日本漫画史

https://docs.opencv.org/2.4/doc/tutorials/imgproc/imgtrans/remap/remap.html

Goal

In this tutorial you will learn how to:

1. Use the OpenCV function remap to implement simple remapping routines.

Theory

Code

1. What does this program do?
   • Loads an image
   • Each second, apply 1 of 4 different remapping processes to the image and display them indefinitely in a window.
   • Wait for the user to exit the program
2. The tutorial code’s is shown lines below. You can also download it from here

 #include "opencv2/highgui/highgui.hpp"  #include "opencv2/imgproc/imgproc.hpp"  #include <iostream>  #include <stdio.h>   using namespace cv;   /// Global variables  Mat src, dst;  Mat map_x, map_y;  char* remap_window = "Remap demo";  int ind = 0;   /// Function Headers  void update_map( void );   /**  * @function main  */  int main( int argc, char** argv )  {    /// Load the image    src = imread( argv[1], 1 );    /// Create dst, map_x and map_y with the same size as src:   dst.create( src.size(), src.type() );   map_x.create( src.size(), CV_32FC1 );   map_y.create( src.size(), CV_32FC1 );    /// Create window   namedWindow( remap_window, CV_WINDOW_AUTOSIZE );    /// Loop   while( true )   {     /// Each 1 sec. Press ESC to exit the program     int c = waitKey( 1000 );      if( (char)c == 27 )       { break; }      /// Update map_x & map_y. Then apply remap     update_map();     remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );      /// Display results     imshow( remap_window, dst );   }   return 0;  }   /**  * @function update_map  * @brief Fill the map_x and map_y matrices with 4 types of mappings  */  void update_map( void )  {    ind = ind%4;     for( int j = 0; j < src.rows; j++ )    { for( int i = 0; i < src.cols; i++ )        {          switch( ind )          {            case 0:              if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 )                {                  map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;                  map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;                 }              else                { map_x.at<float>(j,i) = 0 ;                  map_y.at<float>(j,i) = 0 ;                }                  break;            case 1:                  map_x.at<float>(j,i) = i ;                  map_y.at<float>(j,i) = src.rows - j ;                  break;            case 2:                  map_x.at<float>(j,i) = src.cols - i ;                  map_y.at<float>(j,i) = j ;                  break;            case 3:                  map_x.at<float>(j,i) = src.cols - i ;                  map_y.at<float>(j,i) = src.rows - j ;                  break;          } // end of switch        }     }   ind++; } 

Explanation

1. Create some variables we will use:

   Mat src, dst; Mat map_x, map_y; char* remap_window = "Remap demo"; int ind = 0; 

2. Load an image:

   src = imread( argv[1], 1 ); 

3. Create the destination image and the two mapping matrices (for x and y )

   dst.create( src.size(), src.type() ); map_x.create( src.size(), CV_32FC1 ); map_y.create( src.size(), CV_32FC1 ); 

4. Create a window to display results

   namedWindow( remap_window, CV_WINDOW_AUTOSIZE ); 

5. Establish a loop. Each 1000 ms we update our mapping matrices (mat_x and mat_y) and apply them to our source image:

   while( true ) {   /// Each 1 sec. Press ESC to exit the program   int c = waitKey( 1000 );    if( (char)c == 27 )     { break; }    /// Update map_x & map_y. Then apply remap   update_map();   remap( src, dst, map_x, map_y, CV_INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0, 0) );    /// Display results   imshow( remap_window, dst ); } 

   The function that applies the remapping is remap. We give the following arguments:

   • src: Source image
   • dst: Destination image of same size as src
   • map_x: The mapping function in the x direction. It is equivalent to the first component of 
   • map_y: Same as above, but in y direction. Note that map_y and map_x are both of the same size as src
   • CV_INTER_LINEAR: The type of interpolation to use for non-integer pixels. This is by default.
   • BORDER_CONSTANT: Default

   How do we update our mapping matrices mat_x and mat_y? Go on reading:

6. Updating the mapping matrices: We are going to perform 4 different mappings:

   1. Reduce the picture to half its size and will display it in the middle:

      

      for all pairs  such that:  and 

   2. Turn the image upside down: 

   3. Reflect the image from left to right: 

   4. Combination of b and c: 

This is expressed in the following snippet. Here, map_x represents the first coordinate of h(i,j) and map_y the second coordinate.

for( int j = 0; j < src.rows; j++ ) { for( int i = 0; i < src.cols; i++ )     {       switch( ind )       {         case 0:           if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 )             {               map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;               map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;              }           else             { map_x.at<float>(j,i) = 0 ;               map_y.at<float>(j,i) = 0 ;             }               break;         case 1:               map_x.at<float>(j,i) = i ;               map_y.at<float>(j,i) = src.rows - j ;               break;         case 2:               map_x.at<float>(j,i) = src.cols - i ;               map_y.at<float>(j,i) = j ;               break;         case 3:               map_x.at<float>(j,i) = src.cols - i ;               map_y.at<float>(j,i) = src.rows - j ;               break;       } // end of switch     }   }  ind++; } 

Result

1. After compiling the code above, you can execute it giving as argument an image path. For instance, by using the following image:

   

2. This is the result of reducing it to half the size and centering it:

   

3. Turning it upside down:

   

4. Reflecting it in the x direction:

   

5. Reflecting it in both directions:

• OpenCV => 3.2
• Operating System / Platform => Windows 64 Bit
• Compiler => Visual Studio 2015

Hi everyone, I understand that this forum is to report bugs and not to ask questions but I already posted about my problems in answers.opencv.org without any useful response. I need to resolve my problem very urgently since my final year project deadline is approaching soon.

I am currently working on my project which involves vehicle detection and tracking and estimating and optimizing a cuboid around the vehicle. For that I have accomplished detection and tracking of vehicles and I need to find the 3-D world coordinates of the image points of the edges of the bounding boxes of the vehicles and then estimate the world coordinates of the edges of the cuboid and the project it back to the image to display it.

So, I am new to computer vision and OpenCV, but in my knowledge, I just need 4 points on the image and need to know the world coordinates of those 4 points and use solvePNP in OpenCV to get the rotation and translation vectors (I already have the camera matrix and distortion coefficients). Then, I need to use Rodrigues to transform the rotation vector into a rotation matrix and then concatenate it with the translation vector to get my extrinsic matrix and then multiply the extrinsic matrix with the camera matrix to get my projection matrix. Since my z coordinate is zero, so I need to take off the third column from the projection matrix which gives the homography matrix for converting the 2D image points to 3D world points. Now, I find the inverse of the homography matrix which gives me the homography between the 3D world points to 2D image points. After that I multiply the image points [x, y, 1]t with the inverse homography matrix to get [wX, wY, w]t and the divide the entire vector by the scalar w to get [X, Y, 1] which gives me the X and Y values of the world coordinates.

My code looks like this:

#include "opencv2/opencv.hpp" #include <stdio.h> #include <iostream> #include <sstream> #include <math.h> #include <conio.h>  using namespace cv; using namespace std;  Mat cameraMatrix, distCoeffs, rotationVector, rotationMatrix, translationVector, extrinsicMatrix, projectionMatrix, homographyMatrix, inverseHomographyMatrix;   Point point; vector<Point2d> image_points; vector<Point3d> world_points;  int main() {     FileStorage fs1("intrinsics.yml", FileStorage::READ);     fs1["camera_matrix"] >> cameraMatrix;    cout << "Camera Matrix: " << cameraMatrix << endl << endl;     fs1["distortion_coefficients"] >> distCoeffs;    cout << "Distortion Coefficients: " << distCoeffs << endl << endl;          image_points.push_back(Point2d(275, 204));    image_points.push_back(Point2d(331, 204));    image_points.push_back(Point2d(331, 308));    image_points.push_back(Point2d(275, 308));     cout << "Image Points: " << image_points << endl << endl;     world_points.push_back(Point3d(0.0, 0.0, 0.0));    world_points.push_back(Point3d(1.775, 0.0, 0.0));    world_points.push_back(Point3d(1.775, 4.620, 0.0));    world_points.push_back(Point3d(0.0, 4.620, 0.0));     cout << "World Points: " << world_points << endl << endl;     solvePnP(world_points, image_points, cameraMatrix, distCoeffs, rotationVector, translationVector);    cout << "Rotation Vector: " << endl << rotationVector << endl << endl;    cout << "Translation Vector: " << endl << translationVector << endl << endl;     Rodrigues(rotationVector, rotationMatrix);    cout << "Rotation Matrix: " << endl << rotationMatrix << endl << endl;     hconcat(rotationMatrix, translationVector, extrinsicMatrix);    cout << "Extrinsic Matrix: " << endl << extrinsicMatrix << endl << endl;     projectionMatrix = cameraMatrix * extrinsicMatrix;    cout << "Projection Matrix: " << endl << projectionMatrix << endl << endl;     double p11 = projectionMatrix.at<double>(0, 0),    	p12 = projectionMatrix.at<double>(0, 1),    	p14 = projectionMatrix.at<double>(0, 3),    	p21 = projectionMatrix.at<double>(1, 0),    	p22 = projectionMatrix.at<double>(1, 1),    	p24 = projectionMatrix.at<double>(1, 3),    	p31 = projectionMatrix.at<double>(2, 0),    	p32 = projectionMatrix.at<double>(2, 1),    	p34 = projectionMatrix.at<double>(2, 3);      homographyMatrix = (Mat_<double>(3, 3) << p11, p12, p14, p21, p22, p24, p31, p32, p34);    cout << "Homography Matrix: " << endl << homographyMatrix << endl << endl;     inverseHomographyMatrix = homographyMatrix.inv();    cout << "Inverse Homography Matrix: " << endl << inverseHomographyMatrix << endl << endl;     Mat point2D = (Mat_<double>(3, 1) << image_points[0].x, image_points[0].y, 1);    cout << "First Image Point" << point2D << endl << endl;     Mat point3Dw = inverseHomographyMatrix*point2D;    cout << "Point 3D-W : " << point3Dw << endl << endl;     double w = point3Dw.at<double>(2, 0);    cout << "W: " << w << endl << endl;     Mat matPoint3D;    divide(w, point3Dw, matPoint3D);     cout << "Point 3D: " << matPoint3D << endl << endl;     _getch();    return 0; }

I have got the image coordinates of the four known world points and hard-coded it for simplification.image_points contain the image coordinates of the four points and world_points contain the world coordinates of the four points. I am considering the the first world point as the origin (0, 0, 0) in the world axis and using known distance calculating the coordinates of the other four points. Now after calculating the inverse homography matrix, I multiplied it with [image_points[0].x, image_points[0].y, 1]t which is related to the world coordinate (0, 0, 0). Then I divide the result by the third component w to get [X, Y, 1]. But after printing out the values of X and Y, it turns out they are not 0, 0 respectively. What am doing wrong?

The output of my code is like this:

Camera Matrix: [517.0036881709533, 0, 320;  0, 517.0036881709533, 212;  0, 0, 1]  Distortion Coefficients: [0.1128663679798094;  -1.487790079922432;  0;  0;  2.300571896761067]  Image Points: [275, 204;  331, 204;  331, 308;  275, 308]  World Points: [0, 0, 0;  1.775, 0, 0;  1.775, 4.62, 0;  0, 4.62, 0]  Rotation Vector: [0.661476468596541;  -0.02794460022559267;  0.01206996342819649]  Translation Vector: [-1.394495345140898;  -0.2454153722672731;  15.47126945512652]  Rotation Matrix: [0.9995533907649279, -0.02011656447351923, -0.02209848058392758;  0.002297501163799448, 0.7890323093017149, -0.6143474069013439;  0.02979497438726573, 0.6140222623910194, 0.7887261380159]  Extrinsic Matrix: [0.9995533907649279, -0.02011656447351923, -0.02209848058392758, -1.394495345140898;  0.002297501163799448, 0.7890323093017149, -0.6143474069013439, -0.2454153722672731;  0.02979497438726573, 0.6140222623910194, 0.7887261380159, 15.47126945512652]  Projection Matrix: [526.3071813531748, 186.086785938988, 240.9673682002232, 4229.846989065414;  7.504351145361707, 538.1053336219271, -150.4099339268854, 3153.028471890794;  0.02979497438726573, 0.6140222623910194, 0.7887261380159, 15.47126945512652]  Homography Matrix: [526.3071813531748, 186.086785938988, 4229.846989065414;  7.504351145361707, 538.1053336219271, 3153.028471890794;  0.02979497438726573, 0.6140222623910194, 15.47126945512652]  Inverse Homography Matrix: [0.001930136511648154, -8.512427241879318e-05, -0.5103513244724983;  -6.693679705844383e-06, 0.00242178892313387, -0.4917279870709287;  -3.451449134581896e-06, -9.595179260534558e-05, 0.08513443835773901]  First Image Point[275;  204;  1]  Point 3D-W : [0.003070864657310213;  0.0004761913292736786;  0.06461112415423849]  W: 0.0646111  Point 3D: [21.04004290792539;  135.683117651025;  1] 

1. #include<iostream>  
2. #include<vector>  
3. #include<opencv2/opencv.hpp>  
4.   
5. using namespace cv;  
6. using namespace std;  
7.   
8. int main()  
9. {  
10.     Mat srcImage(Size(600, 600), CV_8UC3, Scalar(0));  
11.   
12.     RNG &rng = theRNG();  
13.   
14.     char key;  
15.     while (1)  
16.     {  
17.         //随机生成一些点  
18.         //首先就是随机生成点的总数量  
19.         int g_nPointCount = rng.uniform(3, 30);  
20.         //接下来就是随机生成一些点的坐标  
21.         vector<Point> points;  
22.         for (int i = 0; i < g_nPointCount; i++)  
23.         {  
24.             Point midPoint;  
25.   
26.             midPoint.x = rng.uniform(srcImage.cols / 4, srcImage.cols * 3 / 4);  
27.             midPoint.y = rng.uniform(srcImage.rows / 4, srcImage.rows * 3 / 4);  
28.   
29.             points.push_back(midPoint);  
30.         }  
31.   
32.         //显示刚刚随机生成的那些点  
33.         for (int i = 0; i < g_nPointCount; i++)  
34.         {  
35.             circle(srcImage, points[i], 0, Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), 3);  
36.         }  
37.   
38.         //在生成的那些随机点中寻找最小包围圆形  
39.         Point2f center;  
40.         float radius;  
41.         minEnclosingCircle(points, center, radius);  
42.   
43.         //根据得到的圆形和半径  绘制圆形  
44.         circle(srcImage, static_cast<Point>(center), (int)radius  
45.             , Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), 3);  
46.   
47.         imshow("【绘制结束后的图像】", srcImage);  
48.   
49.         key = waitKey();  
50.         if (key == 27)  
51.             break;  
52.         else  
53.             srcImage = Scalar::all(0);  
54.     }  
55.   
56.     return 0;  
57. }