全局匹配算法

⑴ 哪种立体匹配算法不是全局匹配算法

SSD不是全局匹配算法，其他都是。

选项中的 4 个词语的意思如下：

A. 动态规划：动态规划（英语：Dynamic programming，简称 DP）是一种在数学、计算机科学和经济学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。

B. 图割：是“图像分割”（Segmentation）的简称。在计算机视觉领域，图像分割指的是将数字图像细分为多个图像子区域（像素的集合）（也被称作超像素）的过程。图像分割的目的是简化或改变图像的表示形式，使得图像更容易理解和分析。图像分割通常用于定位图像中的物体和边界（线，曲线等）。更精确的，图像分割是对图像中的每个像素加标签的一个过程，这一过程使得具有相同标签的像素具有某种共同视觉特性。图像分割的结果是图像上子区域的集合（这些子区域的全体覆盖了整个图像），或是从图像中提取的轮廓线的集合（例如边缘检测）。一个子区域中的每个像素在某种特性的度量下或是由计算得出的特性都是相似的，例如颜色、亮度、纹理。邻接区域在某种特性的度量下有很大的不同。

C. BP：反向传播算法（英语：Backpropagation algorithm，简称：BP算法）是一种监督学习算法，常被用来训练多层感知机。 于 1974 年，Paul Werbos 首次给出了如何训练一般网络的学习算法，而人工神经网络只是其中的特例。不巧的，在当时整个人工神经网络社群中却无人知晓 Paul 所提出的学习算法。直到 80 年代中期，BP算法才重新被 David Rumelhart、Geoffrey Hinton 及 Ronald Williams、David Parker 和 Yann LeCun 独立发现，并获得了广泛的注意，引起了人工神经网络领域研究的第二次热潮。BP算法是对于多层的前向神经网络 Delta 规则的一般化，使用链式法则来迭代的计算每一层的梯度成为可能。BP算法要求每个人工神经元（节点）所使用的激励函数必须是可微的。

D. SSD：固态硬盘（Solid State Disk、Solid State Drive，简称 SSD）是一种以存储器作为永久性存储器的电脑存储设备。虽然 SSD 已不是使用“碟”来记存数据，而是使用 NAND Flash，也没有用来驱动（Drive）旋转的马达，但是人们依照命名习惯，仍然称为固态硬盘（Solid-State Disk）或固态驱动器（Solid-State Drive）。也有翻译为“固存”（“固态存储器”的简称）。

⑵ bilibili问题

。。。为什么分类你会选在C/C++里面

⑶ 图像匹配的算法

迄今为止，人们已经提出了各种各样的图像匹配算法，但从总体上讲，这些匹配算法可以分成关系结构匹配方法、结合特定理论工具的匹配方法、基于灰度信息的匹配方法、基于亚像元匹配方法、基于内容特征的匹配方法五大类型 基于内容特征的匹配首先提取反映图像重要信息的特征，而后以这些特征为模型进行匹配。局部特征有点、边缘、线条和小的区域，全局特征包括多边形和称为结构的复杂的图像内容描述。特征提取的结果是一个含有特征的表和对图像的描述，每一个特征由一组属性表示，对属性的进一步描述包括边缘的定向和弧度，边与线的长度和曲率，区域的大小等。除了局部特征的属性外，还用这些局部特征之间的关系描述全局特征，这些关系可以是几何关系，例如两个相邻的三角形之间的边，或两个边之间的距离可以是辐射度量关系，例如灰度值差别，或两个相邻区域之间的灰度值方差或拓扑关系，例如一个特征受限于另一个特征。人们一般提到的基于特征的匹配绝大多数都是指基于点、线和边缘的局部特征匹配，而具有全局特征的匹配实质上是我们上面提到的关系结构匹配方法。特征是图像内容最抽象的描述，与基于灰度的匹配方法比，特相对于几何图像和辐射影响来说更不易变化，但特征提取方法的计算代价通常较，并且需要一些自由参数和事先按照经验选取的闭值，因而不便于实时应用同时，在纹理较少的图像区域提取的特征的密度通常比较稀少，使局部特征的提 取比较困难。另外，基于特征的匹配方法的相似性度量也比较复杂，往往要以特征属性、启发式方法及闭方法的结合来确定度量方法。基于图像特征的匹配方法可以克服利用图像灰度信息进行匹配的缺点，由于图像的特征点比象素点要少很多，因而可以大大减少匹配过程的计算量同时，特征点的匹配度量值对位置的变化比较敏感，可以大大提高匹配的精确程度而且，特征点的提取过程可以减少噪声的影响，对灰度变化，图像形变以及遮挡等都有较好的适应能力。所以基于图像特征的匹配在实际中的应用越来越广-泛。所使用的特征基元有点特征明显点、角点、边缘点等、边缘线段等。

⑷ SGM半全局匹配算法求助

#include "stdafx.h"
#include <cstdio>
#include <cstring>
#include <iostream>
#include<cv.h>
#include<highgui.h>
#include <cmath>

using namespace std;
const int Width = 1024;
const int Height = 1024;
int Lvalue[Width][Width];

uchar C(int x, int y, int d, IplImage * matchImage, IplImage * baseImage)
{
uchar * pMatchPixel = NULL;
uchar * pBasePixel = NULL;
uchar matchPixel = 0;
uchar basePixel =0;
uchar matchMax = 0;
uchar matchMin = 0;
uchar tempMatch1 = 0;
uchar tempMatch2 = 0;
uchar difPixel = 0;

if (x+d <= matchImage->width && x+d >= 0)
{
pMatchPixel = (uchar *)matchImage->imageData + y*matchImage->widthStep + (x+d);
matchPixel = *pMatchPixel;
pBasePixel= (uchar *)baseImage->imageData + y*baseImage->widthStep + x;
basePixel = *pBasePixel;

//匹配影像上的像素点与其左、右像素点的平均值,线性插值的方法
tempMatch1 = (*pMatchPixel +(*(pMatchPixel -1)))/2;
tempMatch2 = (*pMatchPixel +(*(pMatchPixel +1)))/2;

matchMax = max(max(tempMatch1,tempMatch2),matchPixel);
matchMin = min(min(tempMatch1,tempMatch2),matchPixel);

//赋予视差d时的匹配代价C
//BT法
difPixel = max(max(basePixel - matchMax, matchMin - basePixel),0);

//AD法
//difPixel = abs(basePixel - matchPixel);

return difPixel;
}
else
return 255;
}

int main()
{
IplImage * leftImage = cvLoadImage("headL.png",0);
IplImage * rightImage = cvLoadImage("headR.png",0);

int imageWidth = leftImage->width;
int imageHeight =leftImage->height;
int minLvalue = 1000;
int minL1 = 1000;
int minL2 = 1000;
int P1 = 2;
int P2 = 5;
int disparity= 0;
int minDis = 0;
int maxDis = 21;
int scale = 12;

unsigned char * pPixel = NULL;

#pragma region 实现横向DP（以右影像为准,0度方向）

IplImage * MyDPImage_0 = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
cvZero(MyDPImage_0);

int t3 = clock();
for (int i = 0; i < imageHeight;i++)
{
for (int j = 0; j<imageWidth ;j++)
{
disparity = 0;
minL1 = 1000;
minL2 = 1000;
for (int d = minDis; d <= maxDis; d++)
{
//初始化为代价函数的值
Lvalue[j][d] = C(j, i, d, leftImage, rightImage);
if (j > 0)
{
minL1 = min(minL1, Lvalue[j-1][d]);
}
}

for (int d = minDis; d <= maxDis; d++)
{
if (j > 0)
{
minL2 = min(minL2, Lvalue[j-1][d]);
minL2 = min(minL2, (Lvalue[j-1][d+1] + P1));
minL2 = min(minL2, (Lvalue[j-1][d-1] + P1));
minL2 = min(minL2, (minL1 + P2));
Lvalue[j][d] = Lvalue[j][d] + (minL2 - minL1);
}
}

int max=Lvalue[j][0];
for(int d=minDis;d<=maxDis;++d)
{
if(Lvalue[j][d]<max)
{
disparity=d;
max=Lvalue[j][d];
}
}

disparity=disparity*scale;
//生成视差图
pPixel = (uchar *)MyDPImage_0->imageData + i*MyDPImage_0->widthStep + j;
*pPixel =disparity;
}
}

int t4 = clock();
cout<<"横向DP共用时: "<<t4-t3<<"ms"<<endl;

cvNamedWindow("MyDPImage_0", 1);
cvShowImage("MyDPImage_0", MyDPImage_0);
cvSaveImage("MyDPImage_0.jpg", MyDPImage_0);

#pragma endregion

#pragma region 实现横向DP（以左影像为准，0度方向）

IplImage * MyDPImage_0_L = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
cvZero(MyDPImage_0_L);

for (int i = 0; i < imageHeight;i++)
{
for (int j = 0; j<imageWidth;j++)
{
disparity = 0;
minL1 = 1000;
minL2 = 1000;
for (int d = minDis; d <= maxDis; d++)
{
//初始化为代价函数的值
Lvalue[j][d] = C(j, i, -d, rightImage, leftImage);
if (j > 0)
{
minL1 = min(minL1, Lvalue[j-1][d]);
}
}

for (int d = minDis; d <= maxDis; d++)
{
if (j > 0)
{
minL2 = min(minL2, Lvalue[j-1][d]);
minL2 = min(minL2, (Lvalue[j-1][d+1] + P1));
minL2 = min(minL2, (Lvalue[j-1][d-1] + P1));
minL2 = min(minL2, (minL1 + P2));
Lvalue[j][d] = Lvalue[j][d] + minL2 - minL1;
}

}

int max=Lvalue[j][0];
for(int d=0;d<=maxDis;++d)
{
if(Lvalue[j][d]<max)
{
disparity=d;
max=Lvalue[j][d];
}
}
disparity = disparity * scale;
//生成视差图
pPixel = (uchar *)MyDPImage_0_L->imageData + i*MyDPImage_0_L->widthStep + j;
*pPixel = disparity;
}
}

cvNamedWindow("MyDPImage_0_L", 1);
cvShowImage("MyDPImage_0_L", MyDPImage_0_L);
cvSaveImage("MyDPImage_0_L.jpg", MyDPImage_0_L);

#pragma endregion

#pragma region 一致性检查

uchar * pLeftDepthPixel = NULL;
uchar * pRightDepthPixel = NULL;
uchar leftDepthPixel = 0;
uchar rightDepthPixel =0;
uchar difDepthPixel = 0;
IplImage * CheckImage_0 = cvCloneImage(MyDPImage_0);
cvZero(CheckImage_0);

for (int i = 0; i < imageHeight; i++)
{
for(int j = 0; j < imageWidth; j++)
{
pRightDepthPixel = (uchar *)MyDPImage_0->imageData + i*MyDPImage_0->widthStep + j;
rightDepthPixel = *pRightDepthPixel;

if(j + rightDepthPixel/scale < imageWidth)
{
pLeftDepthPixel = (uchar *)MyDPImage_0_L->imageData + i*MyDPImage_0_L->widthStep + j + rightDepthPixel/scale;
leftDepthPixel = *pLeftDepthPixel;
}
else
leftDepthPixel = 0;

difDepthPixel = abs((leftDepthPixel - rightDepthPixel)/scale);

pPixel = (uchar *)CheckImage_0->imageData + i * CheckImage_0->widthStep +j;
if (difDepthPixel <= 1)
{
*pPixel = rightDepthPixel;
}
else
{
//否则，当前像素的视差值为零
*pPixel = 0;
}
}
}

int lp,rp;
int lx,rx;
for(int i=0;i<imageHeight;i++)
{
for(int j=0;j<imageWidth;j++)
{
int tem = *((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep + j);
if(tem==0)
{
lp = rp = 0;
lx = j;
rx = j;
if(lx-1<0)
lp= *((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep + lx);
while((lp==0)&&( lx-1 >= 0 ))
lp = *((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep + (--lx));

if(rx+1>=imageWidth)
rp = *((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep + rx);
while((rp==0)&&(rx+1<imageWidth))
rp = *((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep +(++rx));

if (lp > rp)
{
*((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep + j) = rp;
}
else
{
*((uchar *)CheckImage_0->imageData+i*CheckImage_0->widthStep + j) = lp;
}
}
}
}

cvSmooth(CheckImage_0,CheckImage_0,CV_MEDIAN,3,0,0);

cvNamedWindow("CheckImage_0", 1);
cvShowImage("CheckImage_0", CheckImage_0);
cvSaveImage("CheckImage_0.jpg", CheckImage_0);

#pragma endregion
cout << "完成！"<<endl;
cvWaitKey(0);
return 0;
}

⑸ B站问题要难死啦，这有11道题帮忙回答一下

#1
Infinite Stratos
#2
凰华女学院
#3
白夜叉
#4

高须龙儿
#5

ssd
#6
9982
#7

热传导
#8

东方projec
#9
《幽灵公主》
#10
苦逼
#11
花泽类

⑹ bilibili会员，求大神

1、俄罗斯
2、同温层堡垒
3、赛文
4、*(ar+i)
5、MikuMikuDance
6、alt+鼠标中键
7、麦哲伦
8、FC
9、IS-85
10、俾斯麦号
11、河北省
12、5个
13、陆小凤
14、Howard
15、辽宁号
16、SSD
17、盐泽兼人
18、203mm
19、低磁滞损失的铁磁性物质
20、郭德纲
21、440Hz
22、淡出
23、听我怒吼
24、纯音乐
25、未来穗香
26、庆应樱井翔
27、400枚各型炮弹
28、AE插件Twitch
29、诺亚
30、男生&女生
大部分来自网络，小部分自己知道的。

⑺ 下列哪种立体匹配算法不是全局匹配算法

Z 因为没这个选项