0%

发表于 更新于 分类于 阅读次数：
本文字数： 151 阅读时长 ≈ 1 分钟

2019年3月21日 下午7:30
OpenCV畸变校正原理以及损失有效像素原理分析 - 一度逍遥 - 博客园

桶形畸变的特征

远离图像中心的地方成像放大率小，因此越远离图像中心的位置畸程度越明显。

损失像素的原因：

裁剪之后：

  1. 相当于与拍摄物体向镜头靠近
  2. 相当于fx=f/dx ，f不变dx变大，所以fx变小了
  3. 导致，像素丢失了

发表于 更新于 分类于 阅读次数：
本文字数： 424 阅读时长 ≈ 1 分钟

2019年3月21日 下午7:30
【机器视觉】张氏法相机标定 - 知乎

总结：

  1. 当我们需要再三维空间空进行定义、表示某个量 or 动作 or 关系 时。有两个工具可以选择：笛卡尔坐标 or 齐次坐标
  2. 目前可以表示的量
    1. 点的齐次坐标
    2. 线的齐次坐标
  3. 可以表示的动作
    1. 点的平移变换
  4. 可以表示的关系
    1. 投影透视关系
  5. 坐标系与矩阵有啥关系：
    1. 坐标系下的坐标，可以用矩阵、向量表示
    2. 然后可以进行部分的运算

为什么要定义齐次坐标：

为什么称之为“齐次”：不论你进行多少“次”的a，在笛卡尔坐标下都一样”齐”

因为：伸缩不变性

为什么有了齐次坐标的表示方式我们就可以描述投影透视关系了呢

利用“齐次”实现[点的平移变换]：

  • 点的表示：P(px,py,pz,1)
  • 在笛卡尔坐标系下
    • 仿射变换实现方式：三分量的旋转矩阵 + 缩放矩阵
    • 平移变换实现方式：无法通过三分量矩阵实现
  • 在齐次坐标下：
    • 平移变换实现方式：通过四分量的矩阵实现

为什么齐次坐标可以区分向量和点

点的齐次坐标：P(px,py,pz,1)
线的齐次坐标：v(v1,v2,v3,0)

发表于 更新于 分类于 阅读次数：
本文字数： 204 阅读时长 ≈ 1 分钟

2019年3月21日 下午7:29
注：

  1. 标定板既可以用于单摄像头，由于求内参
  2. 也可以用来求多(双)摄像头，用于求外参

图像畸变校正详解 - 祥的专栏 - CSDN博客

畸变模型：

构建等式：

  1. 将1-3进行联立，就可以求出imgR(U, V) = imgD(Ud, Vd)这个关系，其中包含5个畸变未知数。
  2. 那么，下一步就是解这其中的5个未知数

求解：

注：标定板的作用就是提供大量的匹配点，套入等式，进行参数求解
【机器视觉】张氏法相机标定 - 知乎

发表于 更新于 分类于 阅读次数：
本文字数： 228 阅读时长 ≈ 1 分钟

2019年3月20日 上午10:23

自定义编译选项的作用：

与ifdef结合可以在cmake阶段，如名字“自定义编译选项”

1
2
3
4
5
6
7
8
#ifdef CHINESE
#include /"ChineseText.h"/
#elif ENGLISH
#include /"EnglishText.h"/
#else
///默认包含中文/
#include /"ChineseText.h"/
#endif

参考：

  1. Cmake自定义编译选项 - 舍予书
  2. CMake 自定义编译选项 - _木头人 - 博客园

发表于 更新于 分类于 阅读次数：
本文字数： 270 阅读时长 ≈ 1 分钟

2019年3月19日 下午12:03
交换机和路由器有什么区别_百度经验

  1. 路由器工作在网络层：
    1. 路由器在网络层，根据IP地址寻址。
    2. 路由器可以处理“TCP/IP”协议，交换机不行
    3. 可以为局域网自动分配IP和虚拟拨号
    4. 路由器可以把一个IP分给多个主机使用，对外IP相同
    5. 路由器可以提供防火墙，交换机不能提供这个功能。
    6. 路由器是用来做网间连接，也就是用来连接不同网络的。
  2. 交换机工作在中继层：
    1. 交换机在中继层，根据“MAC”地址寻址
    2. 交换机只是用来分配网络数据的。
    3. 交换机可以把很多主机连接起来，对外的IP不同。
    4. 交换机是做扩大局域网接入点的，可以让局域网连进更多的电脑。

发表于 更新于 分类于 阅读次数：
本文字数： 2.5k 阅读时长 ≈ 2 分钟

2019年3月19日 上午9:51

针对的问题以及要达到的目的：

  1. 数值计算，我并没有按网上的教程以及一些书的目录的步骤去学习算法，他们很多都是从堆栈开始讲起的。
  2. 我认为这样不好的原因：
    1. 目的性不强，这样会导致学习效率低下，并且会很快忘记。
  3. 我的做法：
    1. 结合当前的切实问题和需要来针对性的练习

主要参考文章：

  1. LeetCode总结 — 数值计算篇 - Code Ganker - CSDN博客
    1. LeetCode Reverse Integer 翻转整数 - Grandyang - 博客园
    2. Reverse Integer — LeetCode - Code Ganker - CSDN博客

链接：

  1. Reverse Integer - LeetCode
  2. Palindrome Number - LeetCode
  3. Sqrt(x) - LeetCode
  4. Pow(x, n) - LeetCode

详情：

  1. Reverse Integer - LeetCode

    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
    class Solution {
    public:
        int reverse(int x) {
            //考虑可以溢出:1000*0009
            
            
            //负数转正数
            int neg = 0;
            
            if(x<0){
                //排除：-128~127中的-128去反128就直接溢出了
                if(x == (-1*INT_MAX -1)) return 0;
                
                x *= -1;
                neg = 1;
            }
            
            //反转
            long long rev=0;
            while(x>0){
                rev = rev*10 + x%10;//赋值的过程都可能溢出，所以要检验
                if(rev > INT_MAX){
                    return 0;
                }
                
                x = x/10;
            }
            
            //检验溢出
            if(rev > INT_MAX){
                return 0;
            }
            else if(neg){
                return -rev;
            }
            else{
                return rev;
            }
            
        }
    };

  2. Palindrome Number - LeetCode

    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
    class Solution {
    public:
        bool isPalindrome(int x) {
            //考虑负数
            if(x<0){
                return false;
            }  
            int div = x;
            int index = 1;
            int ten = 1;
            //统计长度index
            while(div >= 10){
                div = div/10;
                index++;
                //计算倍数
                ten *= 10;
            }
            
            cout<<index<<endl;
            //首尾进行比较
            for(int i=0; i <= index/2 ; i++){
                //取首
                int begin = x/ten;
                begin = begin%10;
                ten /= 10;
                
                int end;
                //计算倍数
                int k = i;
                int temp=1;
                while(k--){
                    temp*=10;
                }
                //取尾
                end = x/(temp);
                end = end%10;
                
                //cout<<begin<<" "<<end <<" "<<i<<endl;
                //比较
                if(begin != end) return false;          
            }
            
            return true;
            
        }
    };

  3. Sqrt(x) - LeetCode

    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
    class Solution {
    public:
        int mySqrt(int x) {
            //变成二分搜索问题
            
            if(x == 0) return 0;
            if(x == 1) return 1;
            
            long long begin=0;
            long long end=x;
            long long mid = (begin+end)/2;
            
            while(begin <= end){
                
                long long temp = mid*mid;
                if(temp == x){
                    return mid;
                }
                else if(temp > x){
                    end = mid;
                }
                else if(temp < x){
                    if((mid+1)*(mid+1) > x){
                        return mid;
                    }
                    begin = mid;
                }
                
                mid = (begin+end)/2;
            }
            return 0;
        }
    };

  4. Pow(x, n) - LeetCode

    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
    /*
    没过的例子：
    1.00000
    -2147483648


    Input
    34.00515
    -3
    Output
    0.00086
    Expected
    3e-05

    2
    -1

    */
    class Solution {
    public:
        double myPow(double x, int n) {
            if(n == 1) return x;
            if(n == 0) return 1;
            
            int flag = 0;
            long long n_2= n;
            if(n < 0){
                flag = 1;
                n_2 *= -1;//-2147483648去反会溢出
            }
            
            double temp = myPow(x,n_2/2);
            if(n_2%2 == 1){
                temp= temp*temp*x;
            }
            else{
                temp= temp*temp;
            }
            cout<<flag<<endl;
            if(flag == 1){
                return 1/temp;
            }
            return temp;
            
        }
    };

发表于 更新于 分类于 阅读次数：
本文字数： 869 阅读时长 ≈ 1 分钟

2019年3月19日 下午4:01

刷题：

Java 讲解理论清晰 认真
力扣:liweiwei1419

LeetCodeAnimation-五分钟学算法

  • 动画