幾種典型的立體匹配演算法
SAD演算法
#include<iostream>
#include<cv.h>
#include<highgui.h>
using namespace std;
int GetHammingWeight(unsigned int value);
int main(){
/*Half of the window size for the census transform*/
int hWin = 11;
int compareLength = (2*hWin+1)*(2*hWin+1 - 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
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 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
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
SSD演算法：
#include<iostream>
#include<cv.h>
#include<highgui.h>
using namespace std;
int GetHammingWeight(unsigned int value);
int main(){
/*Half of the window size for the census transform*/
int hWin = 11;
int compareLength = (2*hWin+1)*(2*hWin+1);
cout<<"hWin: "<<hWin<<"; "<<"compare length: "<<compareLength<<endl;
cout<<"SAD test"<<endl;
// char stopKey;
IplImage * leftImage = cvLoadImage("l2.jpg",0);
IplImage * rightImage = cvLoadImage("r2.jpg",0);
int imageWidth = leftImage->width;
int imageHeight =leftImage->height;
IplImage * SADImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
IplImage * MatchLevelImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
int minDBounds = 0;
int maxDBounds = 31;
cvNamedWindow("Left",1);
cvNamedWindow("Right",1);
cvNamedWindow("Census",1);
cvNamedWindow("MatchLevel",1);
cvShowImage("Left",leftImage);
cvShowImage("Right",rightImage);
/*Census Transform */
int i,j ,m,n,k;
unsigned char centerPixel = 0;
unsigned char neighborPixel = 0;
int bitCount = 0;
unsigned int bigger = 0;
int sum = 0;
unsigned int *matchLevel = new unsigned int[maxDBounds - minDBounds + 1];
int tempMin = 0;
int tempIndex = 0;
unsigned char* dst;
unsigned char* leftSrc = NULL;
unsigned char* rightSrc = NULL;
unsigned char leftPixel = 0;
unsigned char rightPixel =0;
unsigned char subPixel = 0;
for(i = 0 ; i < leftImage->height;i++){
for(j = 0; j< leftImage->width;j++){
for (k = minDBounds;k <= maxDBounds;k++)
{
sum = 0;
for (m = i-hWin; m <= i + hWin;m++)
{
for (n = j - hWin; n <= j + hWin;n++)
{
if (m < 0 || m >= imageHeight || n <0 || n >= imageWidth )
{
subPixel = 0;
}else if (n + k >= imageWidth)
{
subPixel = 0;
}else
{
leftSrc = (unsigned char*)leftImage->imageData
+ m*leftImage->widthStep + n + k;
rightSrc = (unsigned char*)rightImage->imageData
+ m*rightImage->widthStep + n;
leftPixel = *leftSrc;
rightPixel = *rightSrc;
if (leftPixel > rightPixel)
{
subPixel = leftPixel - rightPixel;
}else
{
subPixel = rightPixel -leftPixel;
}
}
sum += subPixel*subPixel;
}
}
matchLevel[k] = sum;
//cout<<sum<<endl;
}
/*尋找最佳匹配點*/
// matchLevel[0] = 1000000;
tempMin = 0;
tempIndex = 0;
for ( m = 1;m < maxDBounds - minDBounds + 1;m++)
{
//cout<<matchLevel[m]<<endl;
if (matchLevel[m] < matchLevel[tempIndex])
{
tempMin = matchLevel[m];
tempIndex = m;
}
}
dst = (unsigned char *)SADImage->imageData + i*SADImage->widthStep + j;
//cout<<"index: "<<tempIndex<<" ";
*dst = tempIndex*8;
dst = (unsigned char *)MatchLevelImage->imageData + i*MatchLevelImage->widthStep + j;
*dst = tempMin;
//cout<<"min: "<<tempMin<<" ";
//cout<< tempIndex<<" " <<tempMin<<endl;
}
//cvWaitKey(0);
}
cvShowImage("Census",SADImage);
cvShowImage("MatchLevel",MatchLevelImage);
cvSaveImage("depth.jpg",SADImage);
cvSaveImage("matchLevel.jpg",MatchLevelImage);
cvWaitKey(0);
cvDestroyAllWindows();
cvReleaseImage(&leftImage);
cvReleaseImage(&rightImage);
return 0;
}
ZSSD演算法：
#include<iostream>
#include<cv.h>
#include<highgui.h>
using namespace std;
int GetHammingWeight(unsigned int value);
int main(){
/*Half of the window size for the census transform*/
int hWin = 11;
int compareLength = (2*hWin+1)*(2*hWin+1);
cout<<"hWin: "<<hWin<<"; "<<"compare length: "<<compareLength<<endl;
cout<<"ZSSD test"<<endl;
// char stopKey;
/* IplImage * leftImage = cvLoadImage("l2.jpg",0);
IplImage * rightImage = cvLoadImage("r2.jpg",0);*/
IplImage * leftImage = cvLoadImage("left.bmp",0);
IplImage * rightImage = cvLoadImage("right.bmp",0);
int imageWidth = leftImage->width;
int imageHeight =leftImage->height;
IplImage * SADImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
IplImage * MatchLevelImage = cvCreateImage(cvGetSize(leftImage),leftImage->depth,1);
int minDBounds = 0;
int maxDBounds = 31;
cvNamedWindow("Left",1);
cvNamedWindow("Right",1);
cvNamedWindow("Census",1);
cvNamedWindow("MatchLevel",1);
cvShowImage("Left",leftImage);
cvShowImage("Right",rightImage);
/*Census Transform */
int i,j ,m,n,k;
unsigned char centerPixel = 0;
unsigned char neighborPixel = 0;
int bitCount = 0;
unsigned int bigger = 0;
int sumLeft = 0;
int sumRight = 0;
int sum =0;
int zSumLeft = 0;
int zSumRight = 0;
unsigned int *matchLevel = new unsigned int[maxDBounds - minDBounds + 1];
int tempMin = 0;
int tempIndex = 0;
unsigned char* dst;
unsigned char* leftSrc = NULL;
unsigned char* rightSrc = NULL;
unsigned char leftPixel = 0;
相關推薦
幾種典型的立體匹配演算法
SAD演算法
#include<iostream>
#include<cv.h>
#include<highgui.h>
using namespace std;
int GetHamm
幾種典型的立體匹配演算法（opencv 1.0 DP 演算法）（比較全）
立體匹配演算法最新動態：http://vision.middlebury.edu/stereo/eval/
介紹立體匹配的基本原理: http://vision.deis.unibo.it/~smatt/Seminars/StereoVision.pdf
立體匹配綜述性文章 ：&n
OpenCV3.4兩種立體匹配演算法效果對比
typedef cv::Point_<short> Point2s;
template <typename T> void filterSpecklesImpl(cv::Mat& img, int newVal, int maxSpeckleSize, int maxDiff
幾種典型應用對系統資源使用的特點
java 訪問量 資源 虛擬內存 數據庫應用 1）以靜態內容為主的Web應用a、小文件居多，並且讀操作頻繁，主要消耗內容
b、優化，盡量在前段使用緩存，如果訪問量較大的情況，使用cdn
c、在高並發訪問時，還存在另外一個，如果網絡帶寬瓶頸，客戶訪問量大且帶寬不夠，就會阻塞網絡2）以動態內容
幾種常用的排序演算法
什麼是演算法
我想很多程式設計師恐怕誤解了「演算法」的意義，一想到演算法就是動態規劃，機器學習之類的高大名詞。演算法其實就是數學中的「解題過程」，解題過程要求精確，考慮各種情況，需要人看得懂。演算法不需要你在鍵盤上選擇什麼程式語言實現，只需要在本子上詳細的寫出每一個步驟就可以了。
演算法真的很重要嗎？
幾種簡單的排序演算法
1.向上氣泡排序
var len = arr.length;
for (var i = 0; i < len - 1; i++) { //比較趟數;
for (var j = len - 1; j > i; j--) { //比較次數
if (arr[j] > arr[j
Leetcode|Longest Palindromic Substring(最長迴文的幾種方法)（Manacher演算法）
Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there ex
Python實現幾種簡單的排序演算法
一.氣泡排序
概念:為一個無序的列表排成有序的
實現過程描述:(升序)
1.比較相鄰的元素,如果第一個比第二個大,就交換他們的位置
2.對每一對相鄰元素重複1的工作,從開始第一隊到最後一對,最後結束的時候最大的數會在後面
3.針對所有元素重複1,2的工作,除了最後一個數,因為最後的數最大
RabbitMQ系列之三 RabbitMQ幾種典型模式
本文詳細介紹簡單模式Simple、工作模式Work、釋出訂閱模式Publish/Subscribe、路由模式Routing、萬用字元模式Topics、遠端呼叫模式RPC(暫不對該佇列模式進行詳解)
模式1：簡單模式（Simple / HelloWorld 單生產單消費） 簡單的傳送與
Appium&Java實現自動化實現移動端幾種典型動作
複製程式碼 /* * @FileName Pinch_Zoom: Pinch_Zoom * @author davieyang * @create 2018-11-22 10:04 */ package testscript; import io.ap
幾種基本的排序演算法總結
準備函式
var arr = []
function swap(arr, a, b) { //交換函式
var temp = arr[a]
arr[a] = arr[b]
arr[b] = temp
}
function random_ar
java中幾種常見的排序演算法實現
在Java中得資料結構比較
| 資料機構 | 優點| 缺點 |
|陣列 | 插入快，在直到下標得情況下可快速地存取| 查詢慢，刪除慢，大小固定 |
|有序陣列 | 比無序得陣列查詢快|刪除和插入慢，大小固定 |
|棧 | 提供後進先出方式的存取| 存取其他項很
深度學習幾種典型架構
machines 容易 相對 mark NPU conn ESS span del 介紹幾種典型的深度學習架構。
卷積神經網絡(CNN)
卷積神經網絡由LeCun提出。在Kaggle競賽中取得了巨大成功。
典型的卷積網絡有兩部分。 第一個是負責特征提取，由一對或多對卷積和子
3.RabbitMQ幾種典型模式
本文詳細介紹簡單模式Simple、工作模式Work、釋出訂閱模式Publish/Subscribe、路由模式Routing、萬用字元模式Topics、遠端呼叫模式RPC(暫不對該佇列模式進行詳解)
模式1：簡單模式（Simple / HelloWorld 單生產
幾種常見的排程演算法
一、處理機排程相關基本概念
1、排程方式和排程演算法的若干準則
1)面向使用者的準則：週轉時間短（CPU執行用時Ts、週轉時間T=Ts+Tw、帶權週轉時間W= T/Ts）、響應時間快、均衡性、截止時間的保證、優先權準則
2)面向系統的準則：系統吞吐量高、處理機利
幾種TCP擁塞控制演算法的分析
幾種TCP擁塞控制演算法的分析擁塞控制演算法是實現TCP的重要元件，目前已有非常多的TCP Congestion Control Algorithm. 不同的演算法有自己的優化特性和工作區域。首先，本文簡單介紹一下TCP擁塞避免演算法的工作原理；其次，介紹Reno, Vega
作業系統虛擬記憶體中的四種典型頁替換演算法(OPT,LRU,FIFO,Clock)
頁面置換：在地址對映過程中，若在頁面中發現所要訪問的頁面不再記憶體中，則產生缺頁中斷(page fault)。當發生缺頁中斷時作業系統必須在記憶體選擇一個頁面將其移出記憶體，以便為即將調入的頁面
讓天下沒有難用的資料庫 » sqlserver中幾種典型的等待
為了準備今年的雙11很久沒有更新blog，在最近的幾次sqlserver問題的排查中，總結了sqlserver幾種典型的等待型別，類似於oracle中的等待事件，如果看到這樣的等待型別時候能夠迅速定位問題的根源,下面通過一則案例來把這些典型的等待處理方法整理出來：
第一種等待.memory等待
早上
幾種常見的排序演算法及它們之間的比較
1.穩定性比較
插入排序、氣泡排序、二叉樹排序、二路歸併排序及其他線形排序是穩定的
選擇排序、希爾排序、快速排序、堆排序是不穩定的
2.時間複雜性比較
插入排序、氣泡排序、選擇排序的時間複雜性為O(n2)
其它非線形排序的時間複雜性為O(nlog2n)
線形排序的
區域性立體匹配演算法BM中的匹配代價聚合方法
Block Matching methods
The following matching costs are defined for patches centered at the pixel positions and .
The matching costs