數字影象處理領域的二十四個典型演算法及vc實現、第一章
轉自：http://blog.csdn.net/v_JULY_v/article/details/6210124
作者:July 二零一一年二月二十六日。
參考：百度百科、維基百科、vc數字影象處理。
--------------------------------------------------
數字影象處理領域的二十四個典型演算法及vc實現、第一章
一、256色轉灰度圖
二、Walsh變換
三、二值化變換
四、閾值變換
五、傅立葉變換
六、離散餘弦變換
數字影象處理領域的二十四個典型演算法及vc實現、第二章
七、高斯平滑
八、影象平移
九、影象縮放
十、影象旋轉
數字影象處理領域的二十四個典型演算法及vc實現、第三章
圖像處理，是對影象進行分析、加工、和處理，使其滿足視覺、心理以及其他要求的技術。影象處理是訊號處理在影象域上的一個應用。目前大多數的影象是以數字形式儲存，因而影象處理很多情況下指數字影象處理。
本文接下來，簡單粗略介紹下數字影象處理領域中的24個經典演算法，然後全部演算法用vc實現。由於篇幅所限，只給出某一演算法的主體程式碼。
ok，請細看。
一、256色轉灰度圖
演算法介紹（百度百科）：
什麼叫灰度圖？任何顏色都有紅、綠、藍三原色組成，假如原來某點的顏色為RGB(R，G，B)，那麼，我們可以通過下面幾種方法，將其轉換為灰度：
1.浮點演算法：Gray=R*0.3+G*0.59+B*0.11
2.整數方法：Gray=(R*30+G*59+B*11)/100
3.移位方法：Gray =(R*28+G*151+B*77)>>8;
4.平均值法：Gray=（R+G+B）/3;
5.僅取綠色：Gray=G；
通過上述任一種方法求得Gray後，將原來的RGB(R,G,B)中的R,G,B統一用Gray替換，形成新的顏色RGB(Gray,Gray,Gray)，用它替換原來的RGB(R,G,B)就是灰度圖了。
灰度分為256階。所以，用灰度表示的影象稱作灰度圖。
程式實現：
ok，知道了什麼叫灰度圖，下面，我們們就來實現此256色灰度圖。
這個Convert256toGray()，即是將256色點陣圖轉化為灰度圖：
void Convert256toGray(HDIB hDIB)
{
LPSTR lpDIB;
// 由DIB控制程式碼得到DIB指標並鎖定DIB
lpDIB = (LPSTR) ::GlobalLock((HGLOBAL)hDIB);
// 指向DIB象素資料區的指標
LPSTR lpDIBBits;
// 指向DIB象素的指標
BYTE * lpSrc;
// 影象寬度
LONG lWidth;
// 影象高度
LONG lHeight;
// 影象每行的位元組數
LONG lLineBytes;
// 指向BITMAPINFO結構的指標（Win3.0）
LPBITMAPINFO lpbmi;
// 指向BITMAPCOREINFO結構的指標
LPBITMAPCOREINFO lpbmc;
// 獲取指向BITMAPINFO結構的指標（Win3.0）
lpbmi = (LPBITMAPINFO)lpDIB;
// 獲取指向BITMAPCOREINFO結構的指標
lpbmc = (LPBITMAPCOREINFO)lpDIB;
// 灰度對映表
BYTE bMap[256];
// 計算灰度對映表（儲存各個顏色的灰度值），並更新DIB調色盤
int i,j;
for (i = 0; i < 256; i ++)
{
// 計算該顏色對應的灰度值
bMap[i] = (BYTE)(0.299 * lpbmi->bmiColors[i].rgbRed +
0.587 * lpbmi->bmiColors[i].rgbGreen +
0.114 * lpbmi->bmiColors[i].rgbBlue + 0.5);
// 更新DIB調色盤紅色分量
lpbmi->bmiColors[i].rgbRed = i;
// 更新DIB調色盤綠色分量
lpbmi->bmiColors[i].rgbGreen = i;
// 更新DIB調色盤藍色分量
lpbmi->bmiColors[i].rgbBlue = i;
// 更新DIB調色盤保留位
lpbmi->bmiColors[i].rgbReserved = 0;
}
// 找到DIB影象象素起始位置
lpDIBBits = ::FindDIBBits(lpDIB);
// 獲取影象寬度
lWidth = ::DIBWidth(lpDIB);
// 獲取影象高度
lHeight = ::DIBHeight(lpDIB);
// 計算影象每行的位元組數
lLineBytes = WIDTHBYTES(lWidth * 8);
// 更換每個象素的顏色索引（即按照灰度對映表換成灰度值）
//逐行掃描
for(i = 0; i < lHeight; i++)
{
//逐列掃描
for(j = 0; j < lWidth; j++)
{
// 指向DIB第i行，第j個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
// 變換
*lpSrc = bMap[*lpSrc];
}
}
//解除鎖定
::GlobalUnlock ((HGLOBAL)hDIB);
}
變換效果（以下若無特別說明，圖示的右邊部分都是為某一演算法變換之後的效果）：
二、Walsh變換
演算法介紹：
有關Walsh變換的深入介紹，請看此論文：http://www.informatics.org.cn/doc/ucit200510/ucit20051005.pdf
程式實現:
函式名稱：WALSH()
引數:
double * f - 指向時域值的指標
double * F - 指向頻域值的指標
r －2的冪數
返回值:無。
說明:該函式用來實現快速沃爾什-哈達瑪變換。
VOID WINAPI WALSH(double *f, double *F, int r)
{
// 沃爾什-哈達瑪變換點數
LONG count;
// 迴圈變數
int i,j,k;
// 中間變數
int bfsize,p;
double *X1,*X2,*X;
// 計算快速沃爾什變換點數
count = 1 << r;
// 分配運算所需的陣列
X1 = new double[count];
X2 = new double[count];
// 將時域點寫入陣列X1
memcpy(X1, f, sizeof(double) * count);
// 蝶形運算
for(k = 0; k < r; k++)
{
for(j = 0; j < 1<<k; j++)
{
bfsize = 1 << (r-k);
for(i = 0; i < bfsize / 2; i++)
{
p = j * bfsize;
X2[i + p] = X1[i + p] + X1[i + p + bfsize / 2];
X2[i + p + bfsize / 2] = X1[i + p] - X1[i + p + bfsize / 2];
}
}
// 互換X1和X2
X = X1;
X1 = X2;
X2 = X;
}
// 調整係數
for(j = 0; j < count; j++)
{
p = 0;
for(i = 0; i < r; i++)
{
if (j & (1<<i))
{
p += 1 << (r-i-1);
}
}
F[j] = X1[p] / count;
}
// 釋放記憶體
delete X1;
delete X2;
}
函式名稱：DIBWalsh1()
引數:
LPSTR lpDIBBits - 指向源DIB影象指標
LONG lWidth - 源影象寬度（象素數）
LONG lHeight - 源影象高度（象素數）
返回值:BOOL - 成功返回TRUE，否則返回FALSE。
說明:該函式用來對影象進行沃爾什-哈達瑪變換。於上面不同的是，此處是將二維
矩陣轉換成一個列向量，然後對該列向量進行一次一維沃爾什-哈達瑪變換。
BOOL WINAPI DIBWalsh1(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
// 指向源影象的指標
unsigned char* lpSrc;
// 迴圈變數
LONG i;
LONG j;
// 進行付立葉變換的寬度和高度（2的整數次方）
LONG w;
LONG h;
// 中間變數
double dTemp;
int wp;
int hp;
// 影象每行的位元組數
LONG lLineBytes;
// 計算影象每行的位元組數
lLineBytes = WIDTHBYTES(lWidth * 8);
// 賦初值
w = 1;
h = 1;
wp = 0;
hp = 0;
// 計算進行離散餘弦變換的寬度和高度（2的整數次方）
while(w * 2 <= lWidth)
{
w *= 2;
wp++;
}
while(h * 2 <= lHeight)
{
h *= 2;
hp++;
}
// 分配記憶體
double *f = new double[w * h];
double *F = new double[w * h];
// 列
for(i = 0; i < w; i++)
{
// 行
for(j = 0; j < h; j++)
{
// 指向DIB第j行，第i個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - j) + i;
// 給時域賦值
f[j + i * w] = *(lpSrc);
}
}
// 呼叫快速沃爾什－哈達瑪變換
WALSH(f, F, wp + hp);
// 列
for(i = 0; i < w; i++)
{
// 行
for(j = 0; j < h; j++)
{
// 計算頻譜
dTemp = fabs(F[i * w + j] * 1000);
// 判斷是否超過255
if (dTemp > 255)
{
// 對於超過的，直接設定為255
dTemp = 255;
}
// 指向DIB第j行，第i個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - j) + i;
// 更新源影象
* (lpSrc) = (BYTE)(dTemp);
}
}
//釋放記憶體
delete f;
delete F;
// 返回
return TRUE;
}
變換效果：
三、二值化變換
演算法描述：
二值化是影象分割的一種方法。在二值化圖象的時候把大於某個臨界灰度值的畫素灰度設為灰度極大值，把小於這個值的畫素灰度設為灰度極小值，從而實現二值化。
根據閾值選取的不同，二值化的演算法分為固定閾值和自適應閾值。 比較常用的二值化方法則有：雙峰法、P引數法、迭代法和OTSU法等。
程式實現：
void CMyDIPView::OnDraw(CDC* pDC)
{
CMyDIPDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
if(pDoc->m_hDIB == NULL)
return ;
// TODO: add draw code for native data here
int i,j;
unsigned char *lpSrc;
LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) pDoc->m_hDIB);
int cxDIB = (int) ::DIBWidth(lpDIB); // Size of DIB - x
int cyDIB = (int) ::DIBHeight(lpDIB); // Size of DIB - y
LPSTR lpDIBBits=::FindDIBBits (lpDIB);
// 計算影象每行的位元組數
long lLineBytes = WIDTHBYTES(cxDIB * 8);
// 每行
for(i = 0; i < cyDIB; i++)
{
// 每列
for(j = 0; j < cxDIB; j++)
{
// 指向DIB第i行，第j個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (cyDIB - 1 - i) + j;
// 計算新的灰度值
//*(lpSrc) = BYTE(255-*lpSrc);
}
}
::GlobalUnlock((HGLOBAL) pDoc->m_hDIB);
CRect rect(0,0,cxDIB,cyDIB), rcDIB(0,0,cxDIB,cyDIB);
::PaintDIB(pDC->m_hDC, &rect, pDoc->m_hDIB, &rcDIB, pDoc->m_palDIB);
}
void CMyDIPView::OnMenuitem32778()
{
// TODO: Add your command handler code here
int i,j;
unsigned char *lpSrc;
CMyDIPDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
if(pDoc->m_hDIB == NULL)
return ;
LPSTR lpDIB = (LPSTR) ::GlobalLock((HGLOBAL) pDoc->m_hDIB);
LPSTR lpDIBBits=::FindDIBBits (lpDIB);
int cxDIB = (int) ::DIBWidth(lpDIB); // Size of DIB - x
int cyDIB = (int) ::DIBHeight(lpDIB); // Size of DIB - y
long lLineBytes = WIDTHBYTES(cxDIB * 8); // 計算影象每行的位元組數
const float c1=150,c2=2.5;
// 每行
for(i = 0; i < cyDIB; i++)
{
// 每列
for(j = 0; j < cxDIB; j++)
{
// 指向DIB第i行，第j個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (cyDIB - 1 - i) + j;
// 計算新的灰度值
if(*lpSrc<122) *lpSrc=BYTE(0);
else *lpSrc = BYTE(255);
}
}
::GlobalUnlock((HGLOBAL) pDoc->m_hDIB);
Invalidate(TRUE);
}
變換效果：
四、閾值變換
演算法描述：
輸入影象像元密度值(灰度、亮度值)按對數函式關係變換為輸出影象。
程式實現：
//引數說明:
//LPSTR lpDIBBits:指向源DIB影象指標
//LONG lWidth:源影象寬度（象素數）
//LONG lHeight:源影象高度（象素數）
//BYTE bThre:閾值
//程式說明:
//該函式用來對影象進行閾值變換。對於灰度值小於閾值的象素直接設定
灰度值為0；灰度值大於閾值的象素直接設定為255。
BOOL WINAPI ThresholdTrans(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, BYTE bThre)
{
// 指向源影象的指標
unsigned char* lpSrc;
// 迴圈變數
LONG i;
LONG j;
// 影象每行的位元組數
LONG lLineBytes;
// 計算影象每行的位元組數
lLineBytes = WIDTHBYTES(lWidth * 8);
// 每行
for(i = 0; i < lHeight; i++)
{
// 每列
for(j = 0; j < lWidth; j++)
{
// 指向DIB第i行，第j個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
// 判斷是否小於閾值
if ((*lpSrc) < bThre)
{
// 直接賦值為0
*lpSrc = 0;
}
else
{
// 直接賦值為255
*lpSrc = 255;
}
}
}
// 返回
return TRUE;
}
五、傅立葉變換
演算法描述：
關於此傅立葉變換演算法的具體介紹，請參考本BLOG文章：十、從頭到尾徹底理解傅立葉變換演算法、上。
程式實現：
函式名稱：FFT()
引數:
complex<double> * TD - 指向時域陣列的指標
complex<double> * FD - 指向頻域陣列的指標
r －2的冪數，即迭代次數
返回值:無。
說明:該函式用來實現快速付立葉變換。
VOID WINAPI FFT(complex<double> * TD, complex<double> * FD, int r)
{
// 付立葉變換點數
LONG count;
// 迴圈變數
int i,j,k;
// 中間變數
int bfsize,p;
// 角度
double angle;
complex<double> *W,*X1,*X2,*X;
// 計算付立葉變換點數
count = 1 << r;
// 分配運算所需儲存器
W = new complex<double>[count / 2];
X1 = new complex<double>[count];
X2 = new complex<double>[count];
// 計算加權係數
for(i = 0; i < count / 2; i++)
{
angle = -i * PI * 2 / count;
W[i] = complex<double> (cos(angle), sin(angle));
}
// 將時域點寫入X1
memcpy(X1, TD, sizeof(complex<double>) * count);
// 採用蝶形演算法進行快速付立葉變換
for(k = 0; k < r; k++)
{
for(j = 0; j < 1 << k; j++)
{
bfsize = 1 << (r-k);
for(i = 0; i < bfsize / 2; i++)
{
p = j * bfsize;
X2[i + p] = X1[i + p] + X1[i + p + bfsize / 2];
X2[i + p + bfsize / 2] = (X1[i + p] - X1[i + p + bfsize / 2]) * W[i * (1<<k)];
}
}
X = X1;
X1 = X2;
X2 = X;
}
// 重新排序
for(j = 0; j < count; j++)
{
p = 0;
for(i = 0; i < r; i++)
{
if (j&(1<<i))
{
p+=1<<(r-i-1);
}
}
FD[j]=X1[p];
}
// 釋放記憶體
delete W;
delete X1;
delete X2;
}
函式名稱：Fourier()
引數:
LPSTR lpDIBBits - 指向源DIB影象指標
LONG lWidth - 源影象寬度（象素數）
LONG lHeight - 源影象高度（象素數）
返回值:BOOL - 成功返回TRUE，否則返回FALSE。
說明:該函式用來對影象進行付立葉變換。
BOOL WINAPI Fourier(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
// 指向源影象的指標
unsigned char* lpSrc;
// 中間變數
double dTemp;
// 迴圈變數
LONG i;
LONG j;
// 進行付立葉變換的寬度和高度（2的整數次方）
LONG w;
LONG h;
int wp;
int hp;
// 影象每行的位元組數
LONG lLineBytes;
// 計算影象每行的位元組數
lLineBytes = WIDTHBYTES(lWidth * 8);
// 賦初值
w = 1;
h = 1;
wp = 0;
hp = 0;
// 計算進行付立葉變換的寬度和高度（2的整數次方）
while(w * 2 <= lWidth)
{
w *= 2;
wp++;
}
while(h * 2 <= lHeight)
{
h *= 2;
hp++;
}
// 分配記憶體
complex<double> *TD = new complex<double>[w * h];
complex<double> *FD = new complex<double>[w * h];
// 行
for(i = 0; i < h; i++)
{
// 列
for(j = 0; j < w; j++)
{
// 指向DIB第i行，第j個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
// 給時域賦值
TD[j + w * i] = complex<double>(*(lpSrc), 0);
}
}
for(i = 0; i < h; i++)
{
// 對y方向進行快速付立葉變換
FFT(&TD[w * i], &FD[w * i], wp);
}
// 儲存變換結果
for(i = 0; i < h; i++)
{
for(j = 0; j < w; j++)
{
TD[i + h * j] = FD[j + w * i];
}
}
for(i = 0; i < w; i++)
{
// 對x方向進行快速付立葉變換
FFT(&TD[i * h], &FD[i * h], hp);
}
// 行
for(i = 0; i < h; i++)
{
// 列
for(j = 0; j < w; j++)
{
// 計算頻譜
dTemp = sqrt(FD[j * h + i].real() * FD[j * h + i].real() +
FD[j * h + i].imag() * FD[j * h + i].imag()) / 100;
// 判斷是否超過255
if (dTemp > 255)
{
// 對於超過的，直接設定為255
dTemp = 255;
}
// 指向DIB第(i<h/2 ? i+h/2 : i-h/2)行，第(j<w/2 ? j+w/2 : j-w/2)個象素的指標
// 此處不直接取i和j，是為了將變換後的原點移到中心
//lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
lpSrc = (unsigned char*)lpDIBBits + lLineBytes *
(lHeight - 1 - (i<h/2 ? i+h/2 : i-h/2)) + (j<w/2 ? j+w/2 : j-w/2);
// 更新源影象
* (lpSrc) = (BYTE)(dTemp);
}
}
// 刪除臨時變數
delete TD;
delete FD;
// 返回
return TRUE;
}
變換效果：
July附註：此傅立葉變換演算法，在本BLOG內有深入具體的介紹，請參考本BLOG內其它文章。
六、離散餘弦變換
演算法描述：
離散餘弦變換（DCT for Discrete Cosine Transform）是與傅立葉變換相關的一種變換，它類似於離散傅立葉變換（DFT for Discrete Fourier Transform），但是隻使用實數。
離散餘弦變換相當於一個長度大概是它兩倍的離散傅立葉變換，這個離散傅立葉變換是對一個實偶函式進行的（因為一個實偶函式的傅立葉變換仍然是一個實偶函式），在有些變形裡面需要將輸入或者輸出的位置移動半個單位（DCT有8種標準型別，其中4種是常見的）。
程式實現：
函式名稱：FFT()
引數:
complex<double> * TD - 指向時域陣列的指標
complex<double> * FD - 指向頻域陣列的指標
r －2的冪數，即迭代次數
返回值:無。
說明:該函式用來實現快速付立葉變換。
VOID WINAPI FFT(complex<double> * TD, complex<double> * FD, int r)
{
// 付立葉變換點數
LONG count;
// 迴圈變數
int i,j,k;
// 中間變數
int bfsize,p;
// 角度
double angle;
complex<double> *W,*X1,*X2,*X;
// 計算付立葉變換點數
count = 1 << r;
// 分配運算所需儲存器
W = new complex<double>[count / 2];
X1 = new complex<double>[count];
X2 = new complex<double>[count];
// 計算加權係數
for(i = 0; i < count / 2; i++)
{
angle = -i * PI * 2 / count;
W[i] = complex<double> (cos(angle), sin(angle));
}
// 將時域點寫入X1
memcpy(X1, TD, sizeof(complex<double>) * count);
// 採用蝶形演算法進行快速付立葉變換
for(k = 0; k < r; k++)
{
for(j = 0; j < 1 << k; j++)
{
bfsize = 1 << (r-k);
for(i = 0; i < bfsize / 2; i++)
{
p = j * bfsize;
X2[i + p] = X1[i + p] + X1[i + p + bfsize / 2];
X2[i + p + bfsize / 2] = (X1[i + p] - X1[i + p + bfsize / 2]) * W[i * (1<<k)];
}
}
X = X1;
X1 = X2;
X2 = X;
}
// 重新排序
for(j = 0; j < count; j++)
{
p = 0;
for(i = 0; i < r; i++)
{
if (j&(1<<i))
{
p+=1<<(r-i-1);
}
}
FD[j]=X1[p];
}
// 釋放記憶體
delete W;
delete X1;
delete X2;
}
函式名稱：DCT()
引數:
double * f - 指向時域值的指標
double * F - 指向頻域值的指標
r －2的冪數
返回值:無。
說明:該函式用來實現快速離散餘弦變換，利用2N點的快速付立葉變換來實現離散餘弦變換。
VOID WINAPI DCT(double *f, double *F, int r)
{
// 離散餘弦變換點數
LONG count;
// 迴圈變數
int i;
// 中間變數
double dTemp;
complex<double> *X;
// 計算離散餘弦變換點數
count = 1<<r;
// 分配記憶體
X = new complex<double>[count*2];
// 賦初值為0
memset(X, 0, sizeof(complex<double>) * count * 2);
// 將時域點寫入陣列X
for(i=0;i<count;i++)
{
X[i] = complex<double> (f[i], 0);
}
// 呼叫快速付立葉變換
FFT(X,X,r+1);
// 調整係數
dTemp = 1/sqrt(count);
// 求F[0]
F[0] = X[0].real() * dTemp;
dTemp *= sqrt(2);
// 求F[u]
for(i = 1; i < count; i++)
{
F[i]=(X[i].real() * cos(i*PI/(count*2)) + X[i].imag() * sin(i*PI/(count*2))) * dTemp;
}
// 釋放記憶體
delete X;
}
函式名稱：DIBDct()
引數:
LPSTR lpDIBBits - 指向源DIB影象指標
LONG lWidth - 源影象寬度（象素數）
LONG lHeight - 源影象高度（象素數）
返回值:BOOL - 成功返回TRUE，否則返回FALSE。
說明:該函式用來對影象進行離散餘弦變換。
BOOL WINAPI DIBDct(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{
// 指向源影象的指標
unsigned char* lpSrc;
// 迴圈變數
LONG i;
LONG j;
// 進行付立葉變換的寬度和高度（2的整數次方）
LONG w;
LONG h;
// 中間變數
double dTemp;
int wp;
int hp;
// 影象每行的位元組數
LONG lLineBytes;
// 計算影象每行的位元組數
lLineBytes = WIDTHBYTES(lWidth * 8);
// 賦初值
w = 1;
h = 1;
wp = 0;
hp = 0;
// 計算進行離散餘弦變換的寬度和高度（2的整數次方）
while(w * 2 <= lWidth)
{
w *= 2;
wp++;
}
while(h * 2 <= lHeight)
{
h *= 2;
hp++;
}
// 分配記憶體
double *f = new double[w * h];
double *F = new double[w * h];
// 行
for(i = 0; i < h; i++)
{
// 列
for(j = 0; j < w; j++)
{
// 指向DIB第i行，第j個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
// 給時域賦值
f[j + i * w] = *(lpSrc);
}
}
for(i = 0; i < h; i++)
{
// 對y方向進行離散餘弦變換
DCT(&f[w * i], &F[w * i], wp);
}
// 儲存計算結果
for(i = 0; i < h; i++)
{
for(j = 0; j < w; j++)
{
f[j * h + i] = F[j + w * i];
}
}
for(j = 0; j < w; j++)
{
// 對x方向進行離散餘弦變換
DCT(&f[j * h], &F[j * h], hp);
}
// 行
for(i = 0; i < h; i++)
{
// 列
for(j = 0; j < w; j++)
{
// 計算頻譜
dTemp = fabs(F[j*h+i]);
// 判斷是否超過255
if (dTemp > 255)
{
// 對於超過的，直接設定為255
dTemp = 255;
}
// 指向DIB第y行，第x個象素的指標
lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
// 更新源影象
* (lpSrc) = (BYTE)(dTemp);
}
}
// 釋放記憶體
delete f;
delete F;
// 返回
return TRUE;
}
變化效果：
更多見下一章： 數字影象處理領域的二十四個典型演算法及vc實現、第二章。本文完。
版權所有，侵權必究。若需轉載，請註明出處。謝謝。
相關文章
- Visual C++數字影象處理典型演算法及實現C++演算法
- 數字影象處理DIP
- 數字影象處理之二維碼影象提取演算法（一）演算法
- 數字影象處理-第一節
- 數字影象處理目錄列表
- MATLAB數字影象處理（二）影象增強Matlab
- 【數字影象處理】三.MFC實現影象灰度、取樣和量化功能詳解
- Android影象處理 - 高斯模糊的原理及實現Android
- [Python影象處理] 七.影象閾值化處理及演算法對比Python演算法
- [Python影象處理] 三.獲取影象屬性、興趣ROI區域及通道處理Python
- 數字自然資源領域的實現路徑
- 【筆記】基於Python的數字影象處理筆記Python
- 神奇的影象處理演算法演算法
- [影象處理] Python+OpenCV實現車牌區域識別及Sobel運算元PythonOpenCV
- 數字影象處理的基本原理和常用方法
- 影象處理的濾鏡演算法演算法
- python數字影象處理（1）：環境安裝與配置Python
- iOS 影象處理 － 影象拼接iOS
- Devops是數字化轉型在IT領域的一個最佳實踐dev
- [Python影象處理] 一.影象處理基礎知識及OpenCV入門函式PythonOpenCV函式
- 【數字影像處理】直方圖均衡化詳解及程式設計實現直方圖程式設計
- MATLAB數字影象處理（一）基礎操作和傅立葉變換Matlab
- 【數字影象處理】七.MFC影象增強之影象普通平滑、高斯平滑、Laplacian、Sobel、Prewitt銳化詳解
- 事件處理器中對領域的操作事件
- 影象處理之影象增強
- UIImage 影象處理UI
- Bayer影象處理
- [Python影象處理] 五.影象融合、加法運算及影象型別轉換Python型別
- 實體領域如何開拓智慧數字經營？
- 柵格影象的處理
- 深度學習影象演算法在內容安全領域的應用深度學習演算法
- 演算法 | 數字影像處理之「中值濾波」演算法
- 影像處理領域的加速運算元收集
- Python-OpenCV 處理影象（七）：影象灰度化處理PythonOpenCV
- Python-OpenCV 處理影象（八）：影象二值化處理PythonOpenCV
- 10個使用Java最廣泛的現實領域Java
- 【數字影象處理】四.MFC對話方塊繪製灰度直方圖直方圖
- 數字孿生五維模型及十大領域應用模型