半全局匹配演算法

『壹』 字元串匹配的傳統演算法

傳統的匹配演算法
串匹配演算法雖然發展了幾十年，然而非常實用的演算法是近年才出現。串匹配問題的研究存在理論研究和實際應用的脫節。那些專門從事演算法研究的學者關心的只是理論上看起來很美妙的演算法——具有很好的時間復雜度。而開發人員只追求實際應用中盡可能快的演算法。兩者之間從不注意對方在干什麼。將理論研究和實際應用結合的演算法(如BNDM演算法)只是近年才出現。在實際應用中常常很難找到適合需求的演算法——這樣的演算法實際上是存在的，但是只有資深專家才比較了解。考慮如下情況，一位軟體開發人員，或者一位計算生物學家，或者一位研究人員，又或者一位學生，對字元串匹配領域並沒有深入了解，可是現在需要處理一個文本搜索問題。那些汗牛充棟的書籍使得閱讀者淹沒在各種匹配演算法的海洋中，卻沒有足夠的知識選擇最適用的演算法。最後，常常導致這樣的局面：選擇一種最簡單的演算法加以實現。這往往導致很差的性能，從而影響整個開發系統的質量。更糟糕的是，選擇了一個理論上看起來很漂亮的演算法，並且花費了大量精力去實現。結果，卻發現實際效果和一個簡單演算法差不多，甚至還不如簡單演算法。因此，應該選用一種「實用」演算法，即在實際應用中性能較好，並且一個普通程序員能在幾小時內完成演算法的實現代碼。另外，在字元串匹配研究領域中，一個人所共知的事實是「演算法的思想越簡單，實際應用的效果越好」。
傳統的串匹配演算法可以概括為前綴搜索、後綴搜索、子串搜索。代表演算法有KMP，Shift-And，Shift-Or，BM，Horspool，BNDM，BOM等。所用到的技術包括滑動窗口、位並行、自動機、後綴樹等。

『貳』 解析一哈c語言中的kmp演算法，bf演算法,kr演算法之間的聯系與區別，盡量淺顯易懂，謝謝！

三種演算法聯系：都是字元串匹配演算法。
區別：
「KMP演算法」：在匹配過程稱，若發生不匹配的情況，如果next[j]>=0，則目標串的指針i不變，將模式串的指針j移動到next[j]的位置繼續進行匹配；若next[j]=-1，則將i右移1位，並將j置0，繼續進行比較。
「BF演算法」是普通的模式匹配演算法，BF演算法的思想就是將目標串S的第一個字元與模式串P的第一個字元進行匹配，若相等，則繼續比較S的第二個字元和P的第二個字元；若不相等，則比較S的第二個字元和P的第一個字元，依次比較下去，直到得出最後的匹配結果。
「KR演算法」在每次比較時，用HASH演算法計算文本串和模式串的HASH映射，通過比較映射值的大小來比較字元串是否匹配。但是考慮到HASH沖突，所以在映射值相同的時候，還需要近一步比較字元串是否相同。但是在每次比較時，需要計算HASH值，所以選擇合適的HASH演算法很重要。
略知一二！

『叄』 人類有多少種交匹配方式

原始社會是平均分配。

她長得非常漂亮，美得既誘惑又天真，非常惹人憐愛。但是她從來沒有真正地投入過愛情。

她雖然美麗，但在潛意識里，並不認為自己值得被愛，她對自己打的分數很低。

和任何男人在一起，她都覺得對方不會對自己真心投入，她都擔心對方會離開，她也一直自我保護從不過分陷入某段感情。

樸素的模式匹配演算法：

演算法思想：從目標串的的第一個字元起與模式串的第一個字元比較，若相等，則繼續對字元進行後續的比較，否則目標串從第二個字元起與模式串的第一個字元重新比較，直至模式串中的每個字元依次和目標串中的一個連續的字元序列相等為止，此時稱為匹配成功，否則匹配失敗。

『肆』 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;
}

『伍』 半全局塊匹配（Semi-Global Block Matching）演算法

最近在做雙目視差估計演算法，在OpenCV里有一些演算法，其中半全局塊匹配（Semi-Global Block Matching，SGBM）演算法具有視差效果好速度快的特點，因此常常被廣泛應用。本文主要討論的就是SGBM演算法。OpenCV的SGBM演算法主要參考了《Stereo Processing by Semiglobal Matching and Mutual Information》這篇論文。

原論文使用的方法是利用互信息熵，而OpenCV使用的是Birchfield和Tomasi的方法（參照《Depth Discontinuities by Pixel-to-Pixel Stereo》）。這里我們分別介紹一下。

所謂的熵，是用來表示隨機變數的不確定性，熵的值越大，信息的不確定性也越大。熵H和互信息MI的定義分別如下：

其中，P _I 代表某個點i的概率分布，也就是灰度直方圖為i的點出現的概率；對應地，P _{I 1 ,I 2} 就是兩個圖對應點i ₁ 和i ₂ 的聯合概率分布，也就是：

Kim等人將上式做了一個改進：利用泰勒展開把H _{I 1 ,I 2} 的計算轉化為求和問題（參見論文《Visual Correspondence Using Energy Minimization and Mutual Information》）。

其中圈中帶叉表示卷積運算，g(i,k)為高斯卷積核。

相應地，邊緣熵以及邊緣概率的計算如下：

這樣的話，互信息的定義為：

MI匹配代價C _MI 為：

其中 q 是點 p 在視差為d的情況下的對應校正點。

原作者使用分層互信息（HMI）進行計算，每一層尺寸減少一半。單次計算的時間復雜度是O(WHD)，即width×height×disparity range，所以上次迭代將會是當前迭代速度的1/8。

這里1/16 ³ 要乘3的原因是小尺寸的隨機視差圖不靠譜，需要迭代3次。我們可以看到，相比於後文的BT方法僅僅慢了14%

對於一個匹配序列M，其代價函數γ(M)表示匹配結果 不 准確的程度，其值越小越好。

其中，κ _occ 表示未匹配的懲罰項(constant occlusion penalty)，κ _r 表示匹配的獎勵項，N _occ 和N _r 分別表示未匹配和匹配的點數。

我們為視差設置一個能量函數E(D)

其中P ₁ 和P ₂ 分別表示視差差值為1和視差差值大於1的懲罰系數，一般P ₁ <P ₂ 。添加兩個正則化項一是為了保持視差圖平滑，二是為了保持邊緣。我們要做的是找到D使得能量函數E(D)最小，但是不幸的是，在二維圖像的這個問題是一個NP-完全問題。為了解決這個問題，原文選擇沿著一圈8個或者16個方向進行優化。

選取使代價聚合最小的視差值min _d S[e _mb ( q ,d),d]即可。

我們看一下stereoSGBM類的參數。

簡單地試了一下：

『陸』 D3群在三維實空間中的矩陣表示是怎麼算的

MVS是一種從具有一定重疊度的多視圖視角中恢復場景的稠密結構的技術，傳統方法利用幾何、光學一致性構造匹配代價，進行匹配代價累積，再估計深度值。雖然傳統方法有較高的深度估計精度，但由於存在缺少紋理或者光照條件劇烈變化的場景中的錯誤匹配，傳統方法的深度估計完整度還有很大的提升空間。近年來卷積神經網路已經成功被應用在特徵匹配上，提升了立體匹配的精度。在這樣的背景下，香港科技大學Yaoyao等人，在2018年提出了一種基於深度學習的端到端深度估計框架——MVSNet。
多視圖立體匹配（Multi-view Stereo， MVS）是計算機領域中一個核心問題。重建多視圖立體匹配，可以認為是拍攝既定場景的一個逆過程。相機映射下，三維場景變換為二維，而多視圖立體匹配重建正好相反，其從這樣子。不同視點拍攝圖像，恢復出真實的三維場景。
傳統的方法使用手工設計的相似性度量指標和正則化方法計算場景的稠密對應關系（比如使用歸一化互相關Normalized Cross-Correlation和半全局匹配semi-global matching）。這些方法在非朗伯體表面、無弱紋理區域的場景可以達到很好的效果。但是在弱紋理區域，人工設計的相似性指標變得不可信，因此導致重建結果不完整。由MVS數據集的排行榜可知，這些方法具有很高的精度，然而在重建的完整度方法還有很大的空間可以提升。
卷積神經網路的研究的最新進展引發了人們完善立體匹配重建熱情。從概念看，基於學習演算法能夠捕獲全局的語義信息，比如基於高光和反射的先驗條件，便於得到更加穩健的匹配。目前已經探求一些兩視圖立體匹配，用神經網路替換手工設計的相似性度量或正則化方法。這些方法展現出更好的結果，並且逐步超過立體匹配領域的傳統方法。事實上，立體匹配任務完全適合使用CNN，因為圖像對是已經過修正過的，因此立體匹配問題轉化為水平方向上逐像素的視差估計。
與雙目立體匹配不同的是，MVS的輸入是任意數目的視圖，這是深度學習方法需要解決的一個棘手的問題。而且只有很少的工作意識到該問題，比如SurfaceNet事先重建彩色體素立方體，將所有像素的顏色信息和相機參數構成一個3D代價體，所構成的3D代價體即為網路的輸入。然而受限於3D代價體巨大的內存消耗，SurfaceNet網路的規模很難增大：SurfaceNet運用了一個啟發式的「分而治之」的策略，對於大規模重建場景則需要花費很長的時間。

『柒』 SGM半全局匹配演算法求助

SGM半全局匹配演算法用c++實現的代碼如下，僅供參考（vs中編譯通過）。

#include"stdafx.h"
#include<cstdio>
#include<cstring>
#include<iostream>
#include<cv.h>
#include<highgui.h>
#include<cmath>
usingnamespacestd;
constintWidth=1024;
constintHeight=1024;
intLvalue[Width][Width];
ucharC(intx,inty,intd,IplImage*matchImage,IplImage*baseImage)
{
uchar*pMatchPixel=NULL;
uchar*pBasePixel=NULL;
ucharmatchPixel=0;
ucharbasePixel=0;
ucharmatchMax=0;
ucharmatchMin=0;
uchartempMatch1=0;
uchartempMatch2=0;
uchardifPixel=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);
returndifPixel;
}
else
return255;
}
intmain()
{
IplImage*leftImage=cvLoadImage("headL.png",0);
IplImage*rightImage=cvLoadImage("headR.png",0);
intimageWidth=leftImage->width;
intimageHeight=leftImage->height;
intminLvalue=1000;
intminL1=1000;
intminL2=1000;
intP1=2;
intP2=5;
intdisparity=0;
intminDis=0;
intmaxDis=21;
intscale=12;
unsignedchar*pPixel=NULL;
#pragmaregion實現橫向DP（以右影像為准,0度方向）
IplImage*MyDPImage_0=cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
cvZero(MyDPImage_0);
intt3=clock();
for(inti=0;i<imageHeight;i++)
{
for(intj=0;j<imageWidth;j++)
{
disparity=0;
minL1=1000;
minL2=1000;
for(intd=minDis;d<=maxDis;d++)
{
//初始化為代價函數的值
Lvalue[j][d]=C(j,i,d,leftImage,rightImage);
if(j>0)
{
minL1=min(minL1,Lvalue[j-1][d]);
}
}
for(intd=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);
}
}
intmax=Lvalue[j][0];
for(intd=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;
}
}
intt4=clock();
cout<<"橫向DP共用時:"<<t4-t3<<"ms"<<endl;
cvNamedWindow("MyDPImage_0",1);
cvShowImage("MyDPImage_0",MyDPImage_0);
cvSaveImage("MyDPImage_0.jpg",MyDPImage_0);
#pragmaendregion
#pragmaregion實現橫向DP（以左影像為准，0度方向）
IplImage*MyDPImage_0_L=cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
cvZero(MyDPImage_0_L);
for(inti=0;i<imageHeight;i++)
{
for(intj=0;j<imageWidth;j++)
{
disparity=0;
minL1=1000;
minL2=1000;
for(intd=minDis;d<=maxDis;d++)
{
//初始化為代價函數的值
Lvalue[j][d]=C(j,i,-d,rightImage,leftImage);
if(j>0)
{
minL1=min(minL1,Lvalue[j-1][d]);
}
}
for(intd=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;
}
}
intmax=Lvalue[j][0];
for(intd=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);
#pragmaendregion
#pragmaregion一致性檢查
uchar*pLeftDepthPixel=NULL;
uchar*pRightDepthPixel=NULL;
ucharleftDepthPixel=0;
ucharrightDepthPixel=0;
uchardifDepthPixel=0;
IplImage*CheckImage_0=cvCloneImage(MyDPImage_0);
cvZero(CheckImage_0);
for(inti=0;i<imageHeight;i++)
{
for(intj=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;
}
}
}
intlp,rp;
intlx,rx;
for(inti=0;i<imageHeight;i++)
{
for(intj=0;j<imageWidth;j++)
{
inttem=*((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);
#pragmaendregion
cout<<"完成！"<<endl;
cvWaitKey(0);
return0;
}