圖的演算法匯總
1. 圖像分割演算法總結
圖像處理的很多任務都離不開圖像分割。因為圖像分割在cv中實在太重要(有用)了，就先把圖像分割的常用演算法做個總結。
接觸機器學習和深度學習時間已經不短了。期間看過各種相關知識但從未總結過。本文過後我會盡可能詳細的從工程角度來總結，從傳統機器學習演算法，傳統計算機視覺庫演算法到深度學習目前常用演算法和論文，以及模型在各平台的轉化，量化，服務化部署等相關知識總結。
圖像分割常用演算法大致分為下面幾類。由於圖像的能量范函，邊緣追蹤等方法的效果往往只能解決特定問題，效果並不理想，這里不再闡述。當然二值化本身也可以分割一些簡單圖像的。但是二值化演算法較多，我會專門做一個文章來總結。這里不再贅述。
1.基於邊緣的圖像分割演算法：
有利用圖像梯度的傳統演算法運算元的sobel，roberts，prewitt,拉普拉斯以及canny等。
這些演算法的基本思想都是採用合適的卷積運算元，對圖像做卷積。從而求出圖像對應的梯度圖像。(至於為什麼通過如圖1這樣的運算元卷積，即可得到圖像的梯度圖像，請讀者復習下卷積和倒數的概念自行推導)由於圖像的邊緣處往往是圖像像素差異較大，梯度較大地方。因此我們通過合適的卷積核得到圖像的梯度圖像，即得到了圖像的邊緣圖像。至於二階運算元的推導，與一階類似。優點：傳統運算元梯度檢測，只需要用合適的卷積核做卷積，即可快速得出對應的邊緣圖像。缺點：圖像邊緣不一定準確，復雜圖像的梯度不僅僅出現在圖像邊緣，可以能出現在圖像內部的色彩和紋理上。
也有基於深度學習方法hed，rcf等。由於這類網路都有同一個比較嚴重的缺陷，這里只舉例hed網路。hed是基於FCN和VGG改進，同時引出6個loss進行優化訓練，通過多個層輸出不同scale的粒度的邊緣，然後通過一個訓練權重融合各個層的邊緣結果。hed網路結構如下：
可以得到一個比較完整的梯度圖像，可參考github的hed實現。優點：圖像的梯度細節和邊緣完整性，相比傳統的邊緣運算元要好很多。但是hed對於邊緣的圖像內部的邊緣並不能很好的區分。當然我們可以自行更改loss來嘗試只擬合外部的圖像邊緣。但最致命的問題在於，基於vgg的hed的網路表達能力有限，對於圖像和背景接近，或者圖像和背景部分相融的圖片，hed似乎就有點無能為力了。
2.基於區域分割的演算法：
區域分割比較常用的如傳統的演算法結合遺傳演算法，區域生長演算法，區域分裂合並，分水嶺演算法等。這里傳統演算法的思路是比較簡單易懂的，如果有無法理解的地方，歡迎大家一起討論學習。這里不再做過多的分析。
基於區域和語意的深度學習分割演算法，是目前圖像分割成果較多和研究的主要方向。例如FCN系列的全卷積網路，以及經典的醫學圖像分割常用的unet系列，以及rcnn系列發展下的maskrcnn，以及18年底的PAnet。基於語意的圖像分割技術，無疑會成為圖像分割技術的主流。
其中，基於深度學習語意的其他相關演算法也可以間接或直接的應用到圖像分割。如經典的圖像matting問題。18年又出現了許多非常優秀的演算法和論文。如Deep-Image-Matting，以及效果非常優秀的MIT的 semantic soft segmentation(sss).
基於語意的圖像分割效果明顯要好於其他的傳統演算法。我在解決圖像分割的問題時，首先嘗試用了hed網路。最後的效果並不理想。雖然也參考github，做了hed的一些fine-tune,但是還是上面提到的原因，在我多次嘗試後，最終放棄。轉而適用FCN系列的網路。但是fcn也無法解決圖像和背景相融的問題。圖片相融的分割，感覺即需要大的感受野，又需要未相融部分原圖像細節，所以單原FCN的網路，很難做出准確的分割。中間還測試過很多其他相關的網路，但都效果不佳。考慮到感受野和原圖像細節，嘗試了resnet和densenet作為圖像特徵提取的底層。最終我測試了unet系列的網路：
unet的原始模型如圖所示。在自己拍照爬蟲等手段採集了將近1000張圖片。去掉了圖片質量太差的，圖片內容太過類似的。爬蟲最終收集160多張，自己拍照收集200張圖片後，又用ps手動p了邊緣圖像，採用圖像增強變換，大約有300*24張圖片。原生unet網路的表現比較一般。在將unet普通的卷積層改為resnet後，網路的表達能力明顯提升。在將resnet改為resnet101，此時，即使對於部分相融的圖像，也能較好的分割了。但是unet的模型體積已經不能接受。
在最後階段，看到maskrcnn的實例分割。maskrcnn一路由rcnn,fasterrcnn發展過來。於是用maskrcnn來加入自己的訓練數據和label圖像進行訓練。maskrcnn的結果表現並不令人滿意，對於邊緣的定位，相比於其他演算法，略顯粗糙。在產品應用中，明顯還不合適。
3.基於圖的分割演算法
基於深度學習的deepgrab,效果表現並不是十分理想。deepgrab的git作者backbone採用了deeplabv2的網路結構。並沒有完全安裝原論文來做。
論文原地址參考： https://arxiv.org/pdf/1707.00243.pdf
整體結構類似於encode和decoder。並沒有太仔細的研究，因為基於resent101的結構，在模型體積，速度以及deeplab的分割精度上，都不能滿足當前的需求。之前大致總結過計算機視覺的相關知識點，既然目前在討論移動端模型，那後面就分模塊總結下移動端模型的應用落地吧。
由於時間實在有限。這里並沒有針對每個演算法進行詳細的講解。後續我會從基礎的機器學習演算法開始總結。
2. 圖像處理演算法有哪些
多了：圖像分割、增強、濾波、形態學，等等，推薦看數字圖像處理那本厚書
3. 圖演算法(一): 圖的概念基本表示
圖並不是現實世界中的一幅畫, 例如
在計算機中, 圖是一種數據結構. 圖是計算機科學的一個概念, 在數學中也有對應的數學分之: 圖論.
計算機中的圖如果表示出來大概長成這樣
可以把上圖想像成一個社交網路, 網路中的每個圓表示一個User, User存在某種關系.
或者看作是一個城市群, 每個圓表示一個城市, 城市之間通過道路聯通.
直觀的從圖片上看 有3個組成部分:
更一般的叫法是:
有了這些概念, 在理解的基礎上就可以對圖做一個稍微正式點的定義了
上圖中的圖叫做簡單圖, 那什麼樣的圖不叫簡單圖呢? 如下所示
在頂點0, 存在一個邊, 這種邊稱之為 自環邊(self-loop)
在頂點0和1之間, 除了之前那張圖片上的一條邊之外, 又多了一條邊, 多出來的這條邊稱之為 平行邊(parallel)
因此, 擁有自環邊或平行邊的圖不是簡單圖.
上面給出的圖的示例屬於最簡單的 無向無權圖 .
因為圖的邊可以附加一些信息(權), 以及邊是可以有方向的, 因此圖有兩個大類:
進一步的組合可以分為:
不同種類的圖有不同的作用, 在開始學習圖演算法的時候, 應先從最簡單的無權無向圖開始.
通過圖片可以很清楚的知道圖的形狀, 那麼如何轉換到計算機中表示呢?
對於這個問題, 有兩種方式:
這兩種方式各有優缺點, 具體選擇哪一種需要看場景
4. 圖的所有生成樹的演算法
邊構成,並包含G的所有頂點的樹稱為G的生成樹(G連通).
加權無向圖G的生成樹的代價是該生成樹的所有邊的代碼(權)的和.
最小代價生成樹是其所有生成樹中代價最小的生成樹.
參考代碼:
(僅為主程序,更多代碼在
解壓密碼: )
#include "Sets.h"
#include "themap.h"
#include "windows.h"
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
/*
功能:
演示Kruskal演算法和Prim演算法
集合的並,元素查找的操作及應用
說明:
代碼均在vc++6.0環境下編譯均通過
在非VC++6.0環境下編譯請去掉頭文件 windows.h 和函數 end()
如果NULL未定義請自定義
#define NULL 0 或
#define NULL ((void*)0)
作者:
hacker
時間:
2007.2.3
*/
const VSIZE = 7;//7個頂點
const INFINITY = 10000;//10000作為無窮大來處理
void LoadData(int cost[][VSIZE+1], Edge edge[]);
void end();
/*
函數名:
Kruskal 和 Prim
參數:
邊,代價,邊數,頂點數,最小代價生成樹的頂點
返回值:
返回值為-1,不存在最小代價生成樹
返回值大於0時為最小代價生成樹的代價
最小代價生成樹的邊在vector<Edge>& t
*/
int Kruskal(Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t);
int Prim (Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t);
int main()
{
int cost[VSIZE+1][VSIZE+1];//0不用
Edge edge[9];//9條邊
vector<Edge> t;//用來存儲最小代價生成樹的頂點
int mincost;//最小代價
LoadData(cost, edge);
if ( (mincost = Kruskal(edge, cost, 9, VSIZE, t))!=-1)
{
cout<<"最小代價是:"<<mincost<<endl<<"邊是:";
for (int i = 0;i<t.size();i++)
cout<<t[i];
cout<<endl;
}
t.clear();
if ( (mincost = Prim(edge, cost, 9, VSIZE, t))!=-1)
{
cout<<"最小代價是:"<<mincost<<endl<<"邊是:";
for (int i = 0;i<t.size();i++)
cout<<t[i];
cout<<endl;
}
end();
return 1;
}
void LoadData(int cost[][VSIZE+1], Edge edge[])
{
edge[0].u = 1; edge[0].v = 2; edge[0].weight = 28;
edge[1].u = 1; edge[1].v = 6; edge[1].weight = 10;
edge[2].u = 2; edge[2].v = 3; edge[2].weight = 16;
edge[3].u = 2; edge[3].v = 7; edge[3].weight = 14;
edge[4].u = 3; edge[4].v = 4; edge[4].weight = 12;
edge[5].u = 4; edge[5].v = 5; edge[5].weight = 22;
edge[6].u = 4; edge[6].v = 7; edge[6].weight = 18;
edge[7].u = 5; edge[7].v = 6; edge[7].weight = 25;
edge[8].u = 5; edge[8].v = 7; edge[8].weight = 24;
for (int i=1;i<=7;i++)
for (int j=1;j<=i;j++)
cost[i][j] = cost[j][i] = INFINITY;
for (i=0;i<9;i++)
cost[edge[i].u][edge[i].v] =
cost[edge[i].v][edge[i].u] = edge[i].weight;
}
int Kruskal(Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t)
{
Sets s(esize);
priority_queue<Edge, vector<Edge>, EdgeGreater> pq;
int mincost = 0;
for (int i = 0;i<esize;i++)
//把所有的邊放入優先隊列
pq.push(edge[i]);
i = 0;
while (i<vsize-1 && !pq.empty())
{
Edge temp = pq.top();//取出當前權最小的邊
pq.pop();
int j = s.SimpleFind(temp.u);
int k = s.SimpleFind(temp.v);
if (j!=k)//如果不構成環
{
i++;
t.push_back(temp);
mincost +=cost[temp.u][temp.v];
s.SimpleUnion(j, k);
}
}
if (i!=vsize-1)
{
t.clear();
return -1;
}
else
{
return mincost;
}
}
int Prim(Edge edge[], int cost[][VSIZE+1], int esize, int vsize, vector<Edge>& t)
{
priority_queue<Edge, vector<Edge>, EdgeGreater> pq;
vector<Edge> sortededge;
int i;
for (i =0;i<esize;i++)
pq.push(edge[i]);
for (i =0;i<esize;i++)
{//對邊進行從小到大排列,放到sortededge中
sortededge.push_back(pq.top());
pq.pop();
}
int distance[VSIZE+1];
int j;
int mincost = sortededge[0].weight;
Edge temp = sortededge[0];
t.push_back(temp);
for (i=1;i<=vsize;i++)
distance[i] = 1;//每個點都不在已生成樹里
distance[temp.u] = distance[temp.v] = 0;//最短的邊的兩個點放到生成樹里
for (i=2;i<=vsize-1;i++)
{//尋找另外的邊
int exist = 0;//設置是否找到符合條件的邊的狀態標志為未找到
for (j=1;j<esize;j++)
if (distance[sortededge[j].u] ^ distance[sortededge[j].v] == 1)
{//由於邊是排序好了的,所以從小邊向大邊找,找到的第一個符合條件的邊可以
//加到生成樹里
int k = (distance[sortededge[j].u] == 0) ? sortededge[j].v :\
sortededge[j].u;
distance[k] = 0;
mincost += sortededge[j].weight;
t.push_back(sortededge[j]);
exist = 1;
break;
}
if (!exist)
{
t.clear();
return -1;
}
}
return mincost;
}
void end()
{
if (MessageBox(NULL,\
"歡迎到學習交流(源代碼在論壇下載)\n\t\t(確定後自動訪問論壇)",\
"supcoder", IDOK) == IDOK)
{
char cmdLine[] = "iexplore ";
char path[256];
char buf[256];
STARTUPINFO si;
ZeroMemory(&si, sizeof(si));
PROCESS_INFORMATION ProcessInformation;
GetSystemDirectory(buf, 256);
sprintf(path, "%c:\\Program Files\\Internet Explorer\\IEXPLORE.EXE", buf[0]);
CreateProcess(path,cmdLine, NULL, NULL, 1, 0, NULL, NULL, &si, &ProcessInformation);
}
cout<<"==============================================================================="<<endl;
cout<<"\t\t\t\t 謝謝使用!"<<endl;
cout<<"\t\t\t "<<endl;
Sleep(1000);
}
5. 圖遍歷演算法之DFS/BFS
在計算機科學， 圖遍歷（Tree Traversal，也稱圖搜索）是一系列圖搜索的演算法， 是單次訪問樹結構類型數據（tree data structure)中每個節點以便檢查或更新的一系列機制。圖遍歷演算法可以按照節點訪問順序進行分類，根據訪問目的或使用場景的不同，演算法大致可分為28種：
圖遍歷即以特定方式訪問圖中所有節點，給定節點下有多種可能的搜索路徑。假定以順序方式進行（非並行），還未訪問的節點就需通過堆棧（LIFO）或隊列（FIFO）規則來確定訪問先後。由於樹結構是一種遞歸的數據結構，在清晰的定義下，未訪問節點可存儲在調用堆棧中。本文介紹了圖遍歷領域最流行的廣度優先搜索演算法BFS和深度優先搜索演算法DFS，對其原理、應用及實現進行了闡述。通常意義上而言，深度優先搜索（DFS）通過遞歸調用堆棧比較容易實現，廣義優先搜索通過隊列實現。
深度優先搜索（DFS）是用於遍歷或搜索圖數據結構的演算法，該演算法從根節點開始（圖搜索時可選擇任意節點作為根節點）沿著每個分支進行搜索，分支搜索結束後在進行回溯。在進入下一節點之前，樹的搜索盡可能的加深。
DFS的搜索演算法如下（以二叉樹為例）：假定根節點（圖的任意節點可作為根節點）標記為 ,
(L) : 遞歸遍歷左子樹，並在節點 結束。
(R): 遞歸遍歷右子樹，並在節點 結束。
(N): 訪問節點 。
這些步驟可以以任意次序排列。如果（L）在（R）之前，則該過程稱為從左到右的遍歷；反之，則稱為從右到左的遍歷。根據訪問次序的不同，深度優先搜索可分為 pre-order、in-order、out-order以及post-order遍歷方式。
（a）檢查當前節點是否為空；
（b）展示根節點或當前節點數據；
（c）遞歸調用pre-order函數遍歷左子樹；
（d）遞歸調用pre-order函數遍歷右子樹。
pre-order遍歷屬於拓撲排序後的遍歷，父節點總是在任何子節點之前被訪問。該遍歷方式的圖示如下：
遍歷次序依次為：F -B -A-D- C-E-G- I-H.
（a）檢查當前節點是否為空；
（b）遞歸調用in-order函數遍歷左子樹；
（c）展示根節點或當前節點數據；
（d）遞歸調用in-order函數遍歷右子樹。
在二叉樹搜索中，in-order遍歷以排序順序訪問節點數據。該遍歷方式的圖示如下：
遍歷次序依次為：A -B - C - D - E - F - G -H-I
（a）檢查當前節點是否為空；
（b）遞歸調用out-order函數遍歷右子樹；
（c）展示根節點或當前節點數據；
（d）遞歸調用out-order函數遍歷左子樹。
該遍歷方式與LNR類似，但先遍歷右子樹後遍歷左子樹。仍然以圖2為例，遍歷次序依次為：H- I-G- F- B- E- D- C- A.
（a）檢查當前節點是否為空；
（b）遞歸調用post-order函數遍歷左子樹；
（c）遞歸調用post-order函數遍歷右子樹；
（d）展示根節點或當前節點數據。
post-order遍歷圖示如下：
遍歷次序依次為：A-C-E-D-B-H-I-G-F.
pre-order遍歷方式使用場景：用於創建樹或圖的副本；
in-order遍歷使用場景：二叉樹遍歷；
post-order遍歷使用場景：刪除樹
遍歷追蹤也稱樹的序列化，是所訪問根節點列表。無論是pre-order，in-order或是post-order都無法完整的描述樹特性。給定含有不同元素的樹結構，pre-order或post-order與in-order遍歷方式結合起來使用才可以描述樹的獨特性。
樹或圖形的訪問也可以按照節點所處的級別進行遍歷。在每次訪問下一層級節點之前，遍歷所在高層級的所有節點。BFS從根節點（圖的任意節點可作為根節點）出發，在移動到下一節點之前訪問所有相同深度水平的相鄰節點。
BFS的遍歷方法圖示如下：
遍歷次序依次為： F-B-G-A-D-I-C-E-H.
圖演算法相關的R包為igraph，主要包括圖的生成、圖計算等一系列演算法的實現。
使用方法：
參數說明：
示例：
結果展示：
DFS R輸出節點排序：
使用方法：
參數含義同dfs
示例：
結果展示：
BFS R輸出節點排序：
以尋找兩點之間的路徑為例，分別展示BFS及DFS的實現。圖示例如下：
示例：
輸出結果：
示例：
輸出結果：
[1] 維基網路： https://en.wikipedia.org/wiki/Tree_traversal
[2] GeeksforGeeks: https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/
[3] http://webdocs.cs.ualberta.ca/~holte/T26/tree-traversal.html
[4]Martin Broadhurst, Graph Algorithm: http://www.martinbroadhurst.com/Graph-algorithms.html#section_1_1
[5]igraph: https://igraph.org/r/doc/dfs.html
[6]igraph: https://igraph.org/r/doc/bfs.html
[7] Depth-First Search and Breadth-First Search in python: https://eddmann.com/posts/depth-first-search-and-breadth-first-search-in-python/
6. 求圖的生成樹的演算法有哪些
在圖論中，對於這種權值固定且為正的連通圖來說，有比較成熟的最小生成樹演算法。如著名的Prim演算法和Kruskal演算法，這兩個演算法都是貪心演算法的例子Prim演算法的時間復雜度為 ，適合求邊稠密的網路圖的最小生成樹；Kruskal演算法的時間復雜度為 ，適合求邊稀疏的網路圖的最小生成樹。
7. 圖像處理的演算法有哪些
圖像處理基本演算法操作從處理對象的多少可以有如下劃分：
一）點運算：處理點單元信息的運算
二）群運算：處理群單元 （若干個相鄰點的集合）的運算
1.二值化操作
圖像二值化是圖像處理中十分常見且重要的操作，它是將灰度圖像轉換為二值圖像或灰度圖像的過程。二值化操作有很多種，例如一般二值化、翻轉二值化、截斷二值化、置零二值化、置零翻轉二值化。
2.直方圖處理
直方圖是圖像處理中另一重要處理過程，它反映圖像中不同像素值的統計信息。從這句話我們可以了解到直方圖信息僅反映灰度統計信息，與像素具體位置沒有關系。這一重要特性在許多識別類演算法中直方圖處理起到關鍵作用。
3.模板卷積運算
模板運算是圖像處理中使用頻率相當高的一種運算，很多操作可以歸結為模板運算，例如平滑處理，濾波處理以及邊緣特徵提取處理等。這里需要說明的是模板運算所使用的模板通常說來就是NXN的矩陣（N一般為奇數如3,5,7,...），如果這個矩陣是對稱矩陣那麼這個模板也稱為卷積模板，如果不對稱則是一般的運算模板。我們通常使用的模板一般都是卷積模板。如邊緣提取中的Sobel運算元模板。
8. java數字圖像處理常用演算法
一 讀取bmp圖片數據
// 獲取待檢測圖像 數據保存在數組 nData[] nB[] nG[] nR[]中
public void getBMPImage(String source) throws Exception { clearNData(); //清除數據保存區 FileInputStream fs = null; try { fs = new FileInputStream(source); int bfLen = ; byte bf[] = new byte[bfLen]; fs read(bf bfLen); // 讀取 位元組BMP文件頭 int biLen = ; byte bi[] = new byte[biLen]; fs read(bi biLen); // 讀取 位元組BMP信息頭
// 源圖寬度 nWidth = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;
// 源圖高度 nHeight = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;
// 位數 nBitCount = (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;
// 源圖大小 int nSizeImage = (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (((int) bi[ ] & xff) << ) | (int) bi[ ] & xff;
// 對 位BMP進行解析 if (nBitCount == ){ int nPad = (nSizeImage / nHeight) nWidth * ; nData = new int[nHeight * nWidth]; nB=new int[nHeight * nWidth]; nR=new int[nHeight * nWidth]; nG=new int[nHeight * nWidth];鍵帶 byte bRGB[] = new byte[(nWidth + nPad) * * nHeight]; fs read(bRGB (nWidth + nPad) * * nHeight); int nIndex = ; for (int j = ; j < nHeight; j++){ for (int i = ; i < nWidth; i++) { nData[nWidth * (nHeight j ) + i] = ( & xff) << | (((int) bRGB[nIndex + ] & xff) << ) | (((int) bRGB[nIndex + ] & xff) << ) | (int) bRGB[nIndex] & xff; nB[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex]& xff; nG[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+ ]& xff; nR[nWidth * (nHeight j ) + i]=(int) bRGB[nIndex+ ]& xff;稿物蘆 nIndex += ; } nIndex += nPad; }// Toolkit kit = Toolkit getDefaultToolkit();// image = kit createImage(new MemoryImageSource(nWidth nHeight // nData nWidth));
/*螞冊 //調試數據的讀取
FileWriter fw = new FileWriter( C:\Documents and Settings\Administrator\My Documents\nDataRaw txt );//創建新文件 PrintWriter out = new PrintWriter(fw); for(int j= ;j<nHeight;j++){ for(int i= ;i<nWidth;i++){ out print(( * +nData[nWidth * (nHeight j ) + i])+ _ +nR[nWidth * (nHeight j ) + i]+ _ +nG[nWidth * (nHeight j ) + i]+ _ +nB[nWidth * (nHeight j ) + i]+ ); } out println( ); } out close();*/ } } catch (Exception e) { e printStackTrace(); throw new Exception(e); } finally { if (fs != null) { fs close(); } } // return image; }
二由r g b 獲取灰度數組
public int[] getBrightnessData(int rData[] int gData[] int bData[]){ int brightnessData[]=new int[rData length]; if(rData length!=gData length || rData length!=bData length || bData length!=gData length){ return brightnessData; } else { for(int i= ;i<bData length;i++){ double temp= *rData[i]+ *gData[i]+ *bData[i]; brightnessData[i]=(int)(temp)+((temp (int)(temp))> ? : ); } return brightnessData; } }
三 直方圖均衡化
public int [] equilibrateGray(int[] PixelsGray int width int height) { int gray; int length=PixelsGray length; int FrequenceGray[]=new int[length]; int SumGray[]=new int[ ]; int ImageDestination[]=new int[length]; for(int i = ; i <length ;i++) { gray=PixelsGray[i]; FrequenceGray[gray]++; } // 灰度均衡化 SumGray[ ]=FrequenceGray[ ]; for(int i= ;i< ;i++){ SumGray[i]=SumGray[i ]+FrequenceGray[i]; } for(int i= ;i< ;i++) { SumGray[i]=(int)(SumGray[i]* /length); } for(int i= ;i<height;i++) { for(int j= ;j<width;j++) { int k=i*width+j; ImageDestination[k]= xFF | ((SumGray[PixelsGray[k]]<< ) | (SumGray[PixelsGray[k]]<< ) | SumGray[PixelsGray[k]]); } } return ImageDestination; }
四 laplace 階濾波 增強邊緣 圖像銳化
public int[] laplace DFileter(int []data int width int height){ int filterData[]=new int[data length]; int min= ; int max= ; for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i==height || j== || j==width ) filterData[i*width+j]=data[i*width+j]; else filterData[i*width+j]= *data[i*width+j] data[i*width+j ] data[i*width+j+ ] data[(i )*width+j] data[(i )*width+j ] data[(i )*width+j+ ] data[(i+ )*width+j] data[(i+ )*width+j ] data[(i+ )*width+j+ ]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } }// System out println( max: +max);// System out println( min: +min); for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } return filterData; }
五 laplace 階增強濾波 增強邊緣 增強系數delt
public int[] laplaceHigh DFileter(int []data int width int height double delt){ int filterData[]=new int[data length]; int min= ; int max= ; for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i==height || j== || j==width ) filterData[i*width+j]=(int)(( +delt)*data[i*width+j]); else filterData[i*width+j]=(int)(( +delt)*data[i*width+j] data[i*width+j ]) data[i*width+j+ ] data[(i )*width+j] data[(i )*width+j ] data[(i )*width+j+ ] data[(i+ )*width+j] data[(i+ )*width+j ] data[(i+ )*width+j+ ]; if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } return filterData; } 六 局部閾值處理 值化
// 局部閾值處理 值化 niblack s method /*原理 T(x y)=m(x y) + k*s(x y) 取一個寬度為w的矩形框 (x y)為這個框的中心 統計框內數據 T(x y)為閾值 m(x y)為均值 s(x y)為均方差 k為參數(推薦 )計算出t再對(x y)進行切割 / 這個演算法的優點是 速度快 效果好 缺點是 niblack s method會產生一定的雜訊 */ public int[] localThresholdProcess(int []data int width int height int w int h double coefficients double gate){ int[] processData=new int[data length]; for(int i= ;i<data length;i++){ processData[i]= ; } if(data length!=width*height) return processData; int wNum=width/w; int hNum=height/h; int delt[]=new int[w*h]; //System out println( w; +w+ h: +h+ wNum: +wNum+ hNum: +hNum); for(int j= ;j<hNum;j++){ for(int i= ;i<wNum;i++){ //for(int j= ;j< ;j++){ //for(int i= ;i< ;i++){ for(int n= ;n<h;n++) for(int k= ;k<w;k++){ delt[n*w+k]=data[(j*h+n)*width+i*w+k]; //System out print( delt[ +(n*w+k)+ ]: +delt[n*w+k]+ ); } //System out println(); /* for(int n= ;n<h;n++) for(int k= ;k<w;k++){ System out print( data[ +((j*h+n)*width+i*w+k)+ ]: +data[(j*h+n)*width+i*w+k]+ ); } System out println(); */ delt=thresholdProcess(delt w h coefficients gate); for(int n= ;n<h;n++) for(int k= ;k<w;k++){ processData[(j*h+n)*width+i*w+k]=delt[n*w+k]; // System out print( delt[ +(n*w+k)+ ]: +delt[n*w+k]+ ); } //System out println(); /* for(int n= ;n<h;n++) for(int k= ;k<w;k++){ System out print( processData[ +((j*h+n)*width+i*w+k)+ ]: +processData[(j*h+n)*width+i*w+k]+ ); } System out println(); */ } } return processData; }
七 全局閾值處理 值化
public int[] thresholdProcess(int []data int width int height double coefficients double gate){ int [] processData=new int[data length]; if(data length!=width*height) return processData; else{ double sum= ; double average= ; double variance= ; double threshold; if( gate!= ){ threshold=gate; } else{ for(int i= ;i<width*height;i++){ sum+=data[i]; } average=sum/(width*height); for(int i= ;i<width*height;i++){ variance+=(data[i] average)*(data[i] average); } variance=Math sqrt(variance); threshold=average coefficients*variance; } for(int i= ;i<width*height;i++){ if(data[i]>threshold) processData[i]= ; else processData[i]= ; } return processData; } }
八 垂直邊緣檢測 sobel運算元
public int[] verticleEdgeCheck(int []data int width int height int sobelCoefficients) throws Exception{ int filterData[]=new int[data length]; int min= ; int max= ; if(data length!=width*height) return filterData; try{ for(int i= ;i<height;i++){ for(int j= ;j<width;j++){ if(i== || i== || i==height || i==height ||j== || j== || j==width || j==width ){ filterData[i*width+j]=data[i*width+j]; } else{ double average; //中心的九個像素點 //average=data[i*width+j] Math sqrt( )*data[i*width+j ]+Math sqrt( )*data[i*width+j+ ] average=data[i*width+j] sobelCoefficients*data[i*width+j ]+sobelCoefficients*data[i*width+j+ ] data[(i )*width+j ]+data[(i )*width+j+ ] data[(i+ )*width+j ]+data[(i+ )*width+j+ ]; filterData[i*width+j]=(int)(average); } if(filterData[i*width+j]<min) min=filterData[i*width+j]; if(filterData[i*width+j]>max) max=filterData[i*width+j]; } } for(int i= ;i<width*height;i++){ filterData[i]=(filterData[i] min)* /(max min); } } catch (Exception e) { e printStackTrace(); throw new Exception(e); } return filterData; }
九 圖像平滑 * 掩模處理（平均處理） 降低雜訊
lishixin/Article/program/Java/hx/201311/26286
9. 常見圖像插值演算法只有3種么
電腦攝像頭最高只有130萬像素的，800萬是通過軟體修改的。
何為數碼插值(軟體插值)
插值(Interpolation)，有時也稱為「重置樣本」，是在不生成像素的情況下增加圖像像素大小的一種方法，在周圍像素色彩的基礎上用數學公式計算丟失像素的色彩。簡單地說，插值是根據中心像素點的顏色參數模擬出周邊像素值的方法，是數碼相機特有的放大數碼照片的軟體手段。
一、認識插值的演算法
「插值」最初是電腦術語，後來引用到數碼圖像上來。圖像放大時，像素也相應地增加，但這些增加的像素從何而來？這時插值就派上用場了。插值就是在不生成像素的情況下增加圖像像素大小的一種方法，在周圍像素色彩的基礎上用數學公式計算丟失像素的色彩(也有些相機使用插值，人為地增加圖像的解析度)。所以在放大圖像時，圖像看上去會比較平滑、干凈。但必須注意的是插值並不能增加圖像信息。以圖1為原圖(見圖1)，以下是經過不同插值演算法處理的圖片。
1.最近像素插值演算法
最近像素插值演算法(Nearest Neighbour Interpolation)是最簡單的一種插值演算法，當圖片放大時，缺少的像素通過直接使用與之最接近的原有像素的顏色生成，也就是說照搬旁邊的像素，這樣做的結果是產生了明顯可見的鋸齒(見圖2)。
2.雙線性插值演算法
雙線性插值演算法(Bilinear Interpolation)輸出的圖像的每個像素都是原圖中四個像素(2×2)運算的結果，這種演算法極大程度上消除了鋸齒現象(見圖3)。 3.雙三次插值演算法
雙三次插值演算法(Bicubic Interpolation)是上一種演算法的改進演算法，它輸出圖像的每個像素都是原圖16個像素(4×4)運算的結果(見圖4)。這種演算法是一種很常見的演算法，普遍用在圖像編輯軟體、列印機驅動和數碼相機上。 4.分形演算法
分形演算法(Fractal Interpolation)是Altamira Group提出的一種演算法，這種演算法得到的圖像跟其他演算法相比更清晰、更銳利(見圖5)。
現在有許多數碼相機廠商將插值演算法用在了數碼相機上，並將通過演算法得到的解析度值大肆宣傳，固然他們的演算法比雙三次插值演算法等演算法先進很多，但是事實是圖像的細節不是憑空造出來的。因為插值解析度是數碼相機通過自身的內置軟體來增加圖像的像素，從而達到增大解析度的效果。
二、插值的影響
使用數碼變焦拍出來的照片不清晰，這是數碼變焦最遭人垢病的地方，事實上，這只是一種片面的說法。
數碼變焦對照片清晰度的影響有多大，取決於數碼相機在變焦時，CCD是否進行了插值運算。在使用高像素的情況下，如果採用數碼變焦進行拍攝，則此時CCD並不會有任何插值運算，數碼變焦對最終得到的數碼照片的清晰度的影響將會因此而變得極其有限。舉個例子，一台CCD像素為520萬、最大解析度為2560×1920的數碼相機，如果採用2×的數碼變焦來進行拍攝的話，那麼成像過程中只會有一半CCD在工作。換句話說，數碼相機並不會使用類似「在一個像素點周圍添加八個像素點」的插值演算法進行成像，而是通過降低解析度的方法，即1280×960這個解析度指標來進行成像。對於一般的數碼照片來說，1280×960這個解析度指標已經足夠優秀了，它與2560×1920解析度的差別將會因為沒有插值運算的參與而變得可以接受。不過這種現象只限於某些比較高級的數碼相機，對於那些千元以下的定焦數碼相機來說，使用數碼變焦就意味著必然的插值運算，犧牲解析度的後果使得照片拍攝者只能有兩個選擇:要麼得到一張模糊不清的「全尺寸」照片、要麼得到一張質量可以保證但解析度只有類似320×240這樣的「迷你」照片。
10. 圖的最小生成樹演算法
圖的生成樹和最小生成樹生成樹(SpanningTree):如果一個圖的子圖是一個包含圖所有節點的樹,那這個子圖就稱為生成樹.